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

#define SWIGPYTHON

#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
#  if defined(__SUNPRO_CC) 
#    define SWIG_TEMPLATE_DISAMBIGUATOR template
#  else
#    define SWIG_TEMPLATE_DISAMBIGUATOR 
#  endif
#endif


#include <Python.h>

/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if !defined(STATIC_LINKED)
#    define SWIGEXPORT(a) __declspec(dllexport) a
#  else
#    define SWIGEXPORT(a) a
#  endif
#else
#  define SWIGEXPORT(a) a
#endif

#define SWIGRUNTIME(x) static x

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


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

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

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

static swig_type_info *swig_type_list = 0;
static swig_type_info **swig_type_list_handle = &swig_type_list;

/* 
   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 ' '.
*/
static 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;
  }
  return (l1 - f1) - (l2 - f2);
}

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

/* Register a type mapping with the type-checking */
static swig_type_info *
SWIG_TypeRegister(swig_type_info *ti) {
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = *swig_type_list_handle;
  while (tc) {
    /* check simple type equivalence */
    int typeequiv = (strcmp(tc->name, ti->name) == 0);   
    /* check full type equivalence, resolving typedefs */
    if (!typeequiv) {
      /* only if tc is not a typedef (no '|' on it) */
      if (tc->str && ti->str && !strstr(tc->str,"|")) {
	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
      }
    }
    if (typeequiv) {
      /* Already exists in the table.  Just add additional types to the list */
      if (ti->clientdata) tc->clientdata = ti->clientdata;
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = *swig_type_list_handle;
  *swig_type_list_handle = ti;

  /* Build linked lists */
  l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;
  head->next = next;

  return ret;
}

/* Check the typename */
static swig_type_info *
SWIG_TypeCheck(char *c, swig_type_info *ty) {
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
static SWIGINLINE void *
SWIG_TypeCast(swig_type_info *ty, void *ptr) {
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* Dynamic pointer casting. Down an inheritance hierarchy */
static 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 */
static SWIGINLINE 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.
*/
static 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->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;
}

/* Search for a swig_type_info structure */
static swig_type_info *
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = *swig_type_list_handle;
  while (ty) {
    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
static void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata) return;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = *swig_type_list_handle;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientData(tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

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

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

/* 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.
*/
static void
SWIG_PropagateClientData(swig_type_info *type) {
  swig_type_info *equiv = type->next;
  swig_type_info *tc;
  if (!type->clientdata) return;
  while (equiv) {
    if (!equiv->converter) {
      tc = *swig_type_list_handle;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
          SWIG_TypeClientData(tc, type->clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * SWIG API. Portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * for internal method declarations
 * ----------------------------------------------------------------------------- */

#ifndef SWIGINTERN
#define SWIGINTERN static 
#endif

#ifndef SWIGINTERNSHORT
#ifdef __cplusplus
#define SWIGINTERNSHORT static inline 
#else /* C case */
#define SWIGINTERNSHORT static 
#endif /* __cplusplus */
#endif

    
/* Common SWIG API */
#define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
 
/* 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_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)

/*
  Exception handling in wrappers
*/
#define SWIG_fail                goto fail
#define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
#define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
#define SWIG_null_ref(type)       SWIG_Python_NullRef(type)

/*
  Contract support
*/
#define SWIG_contract_assert(expr, msg) \
 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else

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

/* Constant Types */
#define SWIG_PY_INT     1
#define SWIG_PY_FLOAT   2
#define SWIG_PY_STRING  3
#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;

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */
/*
  Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
  C/C++ pointers in the python side. Very useful for debugging, but
  not always safe.
*/
#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
#  define SWIG_COBJECT_TYPES
#endif

/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2

/* -----------------------------------------------------------------------------
 * Alloc. memory flags
 * ----------------------------------------------------------------------------- */
#define SWIG_OLDOBJ  1
#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
#define SWIG_PYSTR   SWIG_NEWOBJ + 1

#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.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 ************************************************************************/

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */

typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)();           /* 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;

static PyObject *
swig_varlink_repr(swig_varlinkobject *v) {
  v = v;
  return PyString_FromString("<Global variables>");
}

static int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
  swig_globalvar  *var;
  flags = flags;
  fprintf(fp,"Global variables { ");
  for (var = v->vars; var; var=var->next) {
    fprintf(fp,"%s", var->name);
    if (var->next) fprintf(fp,", ");
  }
  fprintf(fp," }\n");
  return 0;
}

static PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->get_attr)();
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return NULL;
}

static int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->set_attr)(p);
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return 1;
}

static PyTypeObject varlinktype = {
  PyObject_HEAD_INIT(0)              
  0,                                  /* Number of items in variable part (ob_size) */
  (char *)"swigvarlink",              /* Type name (tp_name) */
  sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
  0,                                  /* Itemsize (tp_itemsize) */
  0,                                  /* Deallocator (tp_dealloc) */ 
  (printfunc) swig_varlink_print,     /* Print (tp_print) */
  (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
  (setattrfunc) swig_varlink_setattr, /* Set attr (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 */
  0,                                  /* tp_str */
  0,                                  /* tp_getattro */
  0,                                  /* tp_setattro */
  0,                                  /* tp_as_buffer */
  0,                                  /* tp_flags */
  0,                                  /* 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
#ifdef COUNT_ALLOCS
  /* these must be last */
  0,                                  /* tp_alloc */
  0,                                  /* tp_free */
  0,                                  /* tp_maxalloc */
  0,                                  /*  tp_next */
#endif
};

/* Create a variable linking object for use later */
static PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = 0;
  result = PyMem_NEW(swig_varlinkobject,1);
  varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
  result->ob_type = &varlinktype;
  result->vars = 0;
  result->ob_refcnt = 0;
  Py_XINCREF((PyObject *) result);
  return ((PyObject*) result);
}

static void
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v;
  swig_globalvar *gv;
  v= (swig_varlinkobject *) p;
  gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  gv->name = (char *) malloc(strlen(name)+1);
  strcpy(gv->name,name);
  gv->get_attr = get_attr;
  gv->set_attr = set_attr;
  gv->next = v->vars;
  v->vars = gv;
}

/* -----------------------------------------------------------------------------
 * errors manipulation
 * ----------------------------------------------------------------------------- */

static void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
    if (!PyCObject_Check(obj)) {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? PyString_AsString(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_DECREF(str);
	return;
      }
    } else {
      const char *otype = (char *) PyCObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PyCObject(%s)' is received",
		     type, otype);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);

  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}

static SWIGINLINE void
SWIG_Python_NullRef(const char *type)
{
  if (type) {
    PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
  } else {
    PyErr_Format(PyExc_TypeError, "null reference was received");
  }
}

static 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) {
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
      } else {
	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
      }
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}

static int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    sprintf(mesg, "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}


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

/* Convert a pointer value */
static int
SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c = 0;
  static PyObject *SWIG_this = 0;
  int    newref = 0;
  PyObject  *pyobj = 0;
  void *vptr;
  
  if (!obj) return 0;
  if (obj == Py_None) {
    *ptr = 0;
    return 0;
  }

#ifdef SWIG_COBJECT_TYPES
  if (!(PyCObject_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyCObject_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  }  
  vptr = PyCObject_AsVoidPtr(obj);
  c = (char *) PyCObject_GetDesc(obj);
  if (newref) Py_DECREF(obj);
  goto type_check;
#else
  if (!(PyString_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyString_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  c = PyString_AS_STRING(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      if (newref) { Py_DECREF(obj); }
      *ptr = (void *) 0;
      return 0;
    } else {
      if (newref) { Py_DECREF(obj); }
      goto type_error;
    }
  }
  c++;
  c = SWIG_UnpackData(c,&vptr,sizeof(void *));
  if (newref) { Py_DECREF(obj); }
#endif

type_check:

  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
    *ptr = SWIG_TypeCast(tc,vptr);
  }

  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
  }
  return 0;

type_error:
  PyErr_Clear();
  if (pyobj && !obj) {    
    obj = pyobj;
    if (PyCFunction_Check(obj)) {
      /* here we get the method pointer for callbacks */
      char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
      c = doc ? strstr(doc, "swig_ptr: ") : 0;
      if (c) {
	c += 10;
	if (*c == '_') {
	  c++;
	  c = SWIG_UnpackData(c,&vptr,sizeof(void *));
	  goto type_check;
	}
      }
    }
  }
  if (flags & SWIG_POINTER_EXCEPTION) {
    if (ty) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    } else {
      SWIG_Python_TypeError("C/C++ pointer", obj);
    }
  }
  return -1;
}

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

/* Convert a packed value value */
static int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c = 0;

  if ((!obj) || (!PyString_Check(obj))) goto type_error;
  c = PyString_AS_STRING(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c,ptr,sz);
  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
  }
  return 0;

type_error:
  PyErr_Clear();
  if (flags & SWIG_POINTER_EXCEPTION) {
    if (ty) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    } else {
      SWIG_Python_TypeError("C/C++ packed data", obj);
    }
  }
  return -1;
}

/* Create a new pointer string */
static char *
SWIG_Python_PointerStr(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;
}
  

/* Create a new pointer object */
static PyObject *
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
  PyObject *robj;
  if (!ptr) {
    Py_INCREF(Py_None);
    return Py_None;
  }
#ifdef SWIG_COBJECT_TYPES
  robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
#else
  {
    char result[1024];
    SWIG_Python_PointerStr(result, ptr, type->name, 1024);
    robj = PyString_FromString(result);
  }
#endif
  if (!robj || (robj == Py_None)) return robj;
  if (type->clientdata) {
    PyObject *inst;
    PyObject *args = Py_BuildValue((char*)"(O)", robj);
    Py_DECREF(robj);
    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
    Py_DECREF(args);
    if (inst) {
      if (own) {
        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
      }
      robj = inst;
    }
  }
  return robj;
}

static PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 2 + strlen(type->name)) > 1024) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  strcpy(r,type->name);
  return PyString_FromString(result);
}


/* -----------------------------------------------------------------------------
 * constants/methods manipulation
 * ----------------------------------------------------------------------------- */

/* Install Constants */
static void
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
  int i;
  PyObject *obj;
  for (i = 0; constants[i].type; i++) {
    switch(constants[i].type) {
    case SWIG_PY_INT:
      obj = PyInt_FromLong(constants[i].lvalue);
      break;
    case SWIG_PY_FLOAT:
      obj = PyFloat_FromDouble(constants[i].dvalue);
      break;
    case SWIG_PY_STRING:
      if (constants[i].pvalue) {
	obj = PyString_FromString((char *) constants[i].pvalue);
      } else {
	Py_INCREF(Py_None);
	obj = Py_None;
      }
      break;
    case SWIG_PY_POINTER:
      obj = SWIG_NewPointerObj(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 */
static void
SWIG_Python_FixMethods(PyMethodDef *methods,
		       swig_const_info *const_table,
		       swig_type_info **types,
		       swig_type_info **types_initial) {
  int i;
  for (i = 0; methods[i].ml_name; ++i) {
    char *c = methods[i].ml_doc;
    if (c && (c = strstr(c, "swig_ptr: "))) {
      int j;
      swig_const_info *ci = 0;
      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) {
	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);
	char *buff = ndoc;
	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
	strncpy(buff, methods[i].ml_doc, ldoc);
	buff += ldoc;
	strncpy(buff, "swig_ptr: ", 10);
	buff += 10;
	SWIG_Python_PointerStr(buff, ptr, ty->name, lptr);
	methods[i].ml_doc = ndoc;
      }
    }
  }
}


/* -----------------------------------------------------------------------------
 * Lookup 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 */
static 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 -1;
	}
	if (!o) {
		PyErr_SetString(PyExc_TypeError,
				"PyModule_AddObject() needs non-NULL value");
		return -1;
	}

	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 -1;
	}
	if (PyDict_SetItemString(dict, name, o))
		return -1;
	Py_DECREF(o);
	return 0;
}
#endif
static PyMethodDef swig_empty_runtime_method_table[] = {
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

static void
SWIG_Python_LookupTypePointer(swig_type_info ***type_list_handle) {
  PyObject *module, *pointer;
  void *type_pointer;

  /* first check if module already created */
  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
  if (type_pointer) {
    *type_list_handle = (swig_type_info **) type_pointer;
  } else {
    PyErr_Clear();
    /* create a new module and variable */
    module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    pointer = PyCObject_FromVoidPtr((void *) (*type_list_handle), NULL);
    if (pointer && module) {
      PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    }
  }
}

#ifdef __cplusplus
}
#endif


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

#define  SWIGTYPE_p_GLsizei swig_types[0] 
#define  SWIGTYPE_p_GLshort swig_types[1] 
#define  SWIGTYPE_p_GLboolean swig_types[2] 
#define  SWIGTYPE_size_t swig_types[3] 
#define  SWIGTYPE_p_GLushort swig_types[4] 
#define  SWIGTYPE_p_GLenum swig_types[5] 
#define  SWIGTYPE_p_GLvoid swig_types[6] 
#define  SWIGTYPE_p_GLint swig_types[7] 
#define  SWIGTYPE_p_char swig_types[8] 
#define  SWIGTYPE_p_GLclampd swig_types[9] 
#define  SWIGTYPE_p_GLclampf swig_types[10] 
#define  SWIGTYPE_p_GLuint swig_types[11] 
#define  SWIGTYPE_ptrdiff_t swig_types[12] 
#define  SWIGTYPE_p_GLbyte swig_types[13] 
#define  SWIGTYPE_p_GLbitfield swig_types[14] 
#define  SWIGTYPE_p_GLfloat swig_types[15] 
#define  SWIGTYPE_p_GLubyte swig_types[16] 
#define  SWIGTYPE_p_GLdouble swig_types[17] 
static swig_type_info *swig_types[19];

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


/*-----------------------------------------------
              @(target):= _GL__init__.so
  ------------------------------------------------*/
#define SWIG_init    init_GL__init__

#define SWIG_name    "_GL__init__"

SWIGINTERN PyObject *
SWIG_FromCharPtr(const char* cptr)
{ 
  if (cptr) {
    size_t size = strlen(cptr);
    if (size > INT_MAX) {
      return SWIG_NewPointerObj((char*)(cptr), 
				SWIG_TypeQuery("char *"), 0);
    } else {
      if (size != 0) {
	return PyString_FromStringAndSize(cptr, size);
      } else {
	return PyString_FromString(cptr);
      }
    }
  }
  Py_INCREF(Py_None);
  return Py_None;
}


  /*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/


GLint PyOpenGL_round(double x) {
  if (x >= 0) {
    return (GLint) (x+0.5);
	} else {
    return (GLint) (x-0.5);
	}
}




int __PyObject_AsArray_Size(PyObject* x);

#ifdef NUMERIC

#define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : ((PyArray_Check(x)) ? PyArray_Size(x) : __PyObject_AsArray_Size(x)))

#else /* NUMERIC */

#define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : __PyObject_AsArray_Size(x))

#endif /* NUMERIC */


#define _PyObject_As(NAME, BASE) BASE* _PyObject_As##NAME(PyObject* source, PyObject** temp, int* len);

#define _PyObject_AsArray_Cleanup(target, temp) if (temp) Py_XDECREF(temp); else PyMem_Del(target)

_PyObject_As(FloatArray, float)

_PyObject_As(DoubleArray, double)

_PyObject_As(CharArray, signed char)

_PyObject_As(UnsignedCharArray, unsigned char)

_PyObject_As(ShortArray, short)

_PyObject_As(UnsignedShortArray, unsigned short)

_PyObject_As(IntArray, int)

_PyObject_As(UnsignedIntArray, unsigned int)

void* _PyObject_AsArray(GLenum type, PyObject* source, PyObject** temp, int* len);




#define PyErr_XPrint() if (PyErr_Occurred()) PyErr_Print()


#if HAS_DYNAMIC_EXT

#define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\
RET PROC_NAME PROTO\
{\
	typedef RET (APIENTRY *proc_##PROC_NAME) PROTO;\
	proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\
	if (proc) return proc CALL;\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	return ERROR_RET;\
}

#define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\
void PROC_NAME PROTO\
{\
	typedef void (APIENTRY *proc_##PROC_NAME) PROTO;\
	proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\
	if (proc) proc CALL;\
	else {\
		PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	}\
}

#else

#define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\
RET PROC_NAME PROTO\
{\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	return ERROR_RET;\
}


#define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\
void PROC_NAME PROTO\
{\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
}

#endif


#define _PyTuple_From(NAME, BASE) PyObject* _PyTuple_From##NAME(int len, BASE* data);

_PyTuple_From(UnsignedCharArray, unsigned char)

_PyTuple_From(CharArray, signed char)

_PyTuple_From(UnsignedShortArray, unsigned short)

_PyTuple_From(ShortArray, short)

_PyTuple_From(UnsignedIntArray, unsigned int)

_PyTuple_From(IntArray, int)

_PyTuple_From(FloatArray, float)

_PyTuple_From(DoubleArray, double)


#define _PyObject_From(NAME, BASE) PyObject* _PyObject_From##NAME(int nd, int* dims, BASE* data, int own);

_PyObject_From(UnsignedCharArray, unsigned char)

_PyObject_From(CharArray, signed char)

_PyObject_From(UnsignedShortArray, unsigned short)

_PyObject_From(ShortArray, short)

_PyObject_From(UnsignedIntArray, unsigned int)

_PyObject_From(IntArray, int)

_PyObject_From(FloatArray, float)

_PyObject_From(DoubleArray, double)


PyObject* _PyObject_FromArray(GLenum type, int nd, int *dims, void* data, int own);

void* SetupPixelRead(int rank, GLenum format, GLenum type, int *dims);

void SetupPixelWrite(int rank);

void* SetupRawPixelRead(GLenum format, GLenum type, int n, const int *dims, int* size);

void* _PyObject_AsPointer(PyObject* x);

/* The following line causes a warning on linux and cygwin

	The function is defined in interface_utils.c, which is
	linked to each extension module.  For some reason, though,
	this declaration doesn't get recognised as a declaration
	prototype for that function.
*/
void init_util();

typedef void *PTR;

typedef struct
{
	void (*_decrement)(void* pointer);
	void (*_decrementPointer)(GLenum pname);
	int (*_incrementLock)(void *pointer);
	int (*_incrementPointerLock)(GLenum pname);
	void (*_acquire)(void* pointer);
	void (*_acquirePointer)(GLenum pname);
#if HAS_DYNAMIC_EXT
	PTR (*GL_GetProcAddress)(const char* name);
#endif
	int (*InitExtension)(const char *name, const char** procs);
	PyObject *_GLerror;
	PyObject *_GLUerror;
}  util_API;




#ifndef GL_VERSION_1_1
PyObject *contexts;

typedef struct
{
	PyObject_HEAD
	GLenum feedback_type;
	GLfloat *feedback_buffer;
	GLuint *selection_buffer;
} PyGLcontext;


static void PyGLcontext_Del(PyObject *self)
{
	PyObject_Del(self);
}


PyTypeObject PyGLcontext_Type =
{
    PyObject_HEAD_INIT(0)
    0,									// ob_size
    "GLcontext",					// tp_name
    sizeof(PyGLcontext),			// tp_basicsize
    0,									// tp_itemsize
    PyGLcontext_Del,				// tp_dealloc
};


PyGLcontext* PyGLcontext_New()
{
	PyGLcontext *self = PyObject_NEW(PyGLcontext, &PyGLcontext_Type);

	self->feedback_buffer = NULL;
	self->selection_buffer = NULL;

	return self;
}


PyGLcontext *GetGLcontext()
{
	if (CurrentContextIsValid())
	{
		PyObject *key = PyInt_FromLong(GetCurrentContext());
		PyGLcontext *context = (PyGLcontext*)PyDict_GetItem(contexts, key);
		if (!context)
		{
			context = PyGLcontext_New();
			PyDict_SetItem(contexts, key, (PyObject*)context);
		}
		Py_DECREF(key);
		return context;
	}
	return NULL;
}

#endif /* GL_VERSION_1_1 */

#define POINTER_COUNT 6

typedef struct
{
	void *pointers[POINTER_COUNT+1];
	int ref_count;
} PointerLock;

PointerLock *PointerLocks = NULL;
int PointerLockCount = 0;

GLenum *PointerTypes = NULL;
int PointerTypeCount = 0;

#ifndef GL_VERSION_1_1
#if !EXT_DEFINES_PROTO || !defined(GL_EXT_vertex_array)
DECLARE_VOID_EXT(glGetPointervEXT, (GLenum pname, void** params)), (GLenum pname, void** params))
#endif

static char *va_proc_names[] =
{
#if !EXT_DEFINES_PROTO || !defined(GL_EXT_vertex_array)
	"glGetPointervEXT",
#endif
	NULL
};

int InitExtension(const char* name, const char** procs);

void glGetPointerv(GLenum pname, void** params)
{
	if (InitExtension("GL_EXT_vertex_array", va_proc_names))
	{
		glGetPointervEXT(pname, params);
	} else {
		printf( "Critical failure, unable to load GL_EXT_vertex_array, expect crashes when accessing array pointers" );
	}
}
#endif /* GL_VERSION_1_1 */

/* decrementLock a pointer */
void decrementLock(void* pointer)
{
	if (pointer && PointerLocks)
	{
		int i, j;
		for (i = 0; i < PointerLockCount; i++)
		{
			for (j = 0; j < POINTER_COUNT+1; j++)
			{
				if (PointerLocks[i].pointers[j] == pointer && --PointerLocks[i].ref_count == 0)
				{
					int k;
					PyMem_Free(PointerLocks[i].pointers[0]);
					PointerLockCount--;
					for (k = i; k < PointerLockCount; k++) PointerLocks[k] = PointerLocks[k+1];
					return;
				}
			}
		}
	}
}


/* decrementLock a pointer referenced by glSelectBuffer, glFeedbackBuffer, glColorPointer, etc. */
void decrementPointerLock(GLenum pname)
{
	void* pointer = NULL;
	glGetPointerv(pname, &pointer);
	decrementLock(pointer);
}


void decrementAllLocks()
{
	int i;
	
	for (i = 0; i < PointerTypeCount; i++) decrementPointerLock(PointerTypes[i]);
}


/* increment pointer lock */
int incrementLock(void *pointer)
{
	if (pointer && PointerLocks)
	{
		int i, j;
		
		for (i = 0; i < PointerLockCount; i++)
		{
			for (j = 0; j < POINTER_COUNT+1; j++)
			{
				if (PointerLocks[i].pointers[j] == pointer)
				{
					PointerLocks[i].ref_count++;
					return 1;
				}
			}
		}
	}

	return 0;
}


void addPointerType(GLenum type)
{
	int i;
	
	for (i = 0; i < PointerTypeCount; i++) if (PointerTypes[i] == type) return;
	
	PointerTypes = (PointerTypes) ? PyMem_Resize(PointerTypes, GLenum, ++PointerTypeCount) : PyMem_New(GLenum, PointerTypeCount = 1);
	
	PointerTypes[PointerTypeCount-1] = type;
}


int incrementPointerLock(GLenum pname)
{
	void* pointer = NULL;
	int found;
	
	glGetPointerv(pname, &pointer);
	found = incrementLock(pointer);
	if (found) addPointerType(pname);

	return found;
}


void incrementAllLocks()
{
	int i;
	
	for (i = 0; i < PointerTypeCount; i++) incrementPointerLock(PointerTypes[i]);
}


/* acquire a pointer */
void acquire(void* pointer)
{
	if (pointer)
	{
		int i;
		PointerLock *lock;

		PointerLocks = (PointerLocks) ? PyMem_Resize(PointerLocks, PointerLock, ++PointerLockCount) : PyMem_New(PointerLock, PointerLockCount = 1);
		lock = PointerLocks + PointerLockCount - 1;
		(*lock).pointers[0] = pointer;
		(*lock).ref_count = 1;

		for (i = 1; i < POINTER_COUNT+1; i++) (*lock).pointers[i] = NULL;
	}
}

void acquirePointer(GLenum pname)
{
	void* pointer = NULL;
	glGetPointerv(pname, &pointer);
	acquire(pointer);
	addPointerType(pname);
}

void acquireInterleavedPointer(void* pointer, GLenum pnames[POINTER_COUNT])
{
	if (pointer)
	{
		int i;
		PointerLock *lock;

		PointerLocks = (PointerLocks) ? PyMem_Resize(PointerLocks, PointerLock, ++PointerLockCount) : PyMem_New(PointerLock, PointerLockCount = 1);
		lock = PointerLocks + PointerLockCount - 1;
		(*lock).pointers[0] = pointer;
		(*lock).ref_count = 0;

		for (i = 0; i < POINTER_COUNT; i++)
		{
			(*lock).pointers[i+1] = NULL;
			if (pnames[i])
			{
				glGetPointerv(pnames[i], (*lock).pointers + i + 1);
				if ((*lock).pointers[i+1])
				{
					addPointerType(pnames[i]);
					(*lock).ref_count++;
				}
			}
		}
	}
}

int in_extension_list(const char* name, char *list)
{
	size_t len = strlen(name);
	
	while (list && strlen(list))
	{
		if (strlen(list) >= len && !strncmp(list, name, len)) return 1;
		list = strchr(list, ' ');
		if (!list) return 0;
		list++;
	}

	return 0;
}


const char* GetPlatformExtensionsString();
void* GetExtProc(const char* name);

int has_extension(const char* name)
{
	if (CurrentContextIsValid())
	{
		return in_extension_list(name, (char*)glGetString(GL_EXTENSIONS)) ||
		       in_extension_list(name, (char*)gluGetString(GLU_EXTENSIONS)) ||
		       in_extension_list(name, (char*)GetPlatformExtensionsString());
	}

	return 0;
}


#if HAS_DYNAMIC_EXT
PyObject *ProcAddresses = NULL;

void *GL_GetProcAddress(const char* name)
{
	void *address = NULL;
	if (CurrentContextIsValid())
	{
		PyObject *key = Py_BuildValue("ls", GetCurrentContext(), name);
		PyObject *py_address = PyDict_GetItem(ProcAddresses, key);
		if (py_address) address = PyCObject_AsVoidPtr(py_address);
		Py_DECREF(key);
	}
	return address;
}
#endif

int InitExtension(const char* name, const char** procs)
{
	if (has_extension(name))
	{
		int success = 1;
		void *proc;
		PyObject *key;
#if HAS_DYNAMIC_EXT
		while (*procs)
		{
			key = Py_BuildValue("ls", GetCurrentContext(), *procs);
			if (PyDict_GetItem(ProcAddresses, key)) break;
			proc = (void*)GetExtProc(*procs);
			if (proc)
			{
				PyDict_SetItem(ProcAddresses, key, PyCObject_FromVoidPtr(proc, NULL));
			}
			Py_DECREF(key);
			procs++;
		}
#endif
		return success;
	}
	return 0;
}

static util_API _util_API;

PyObject *GLerror = NULL;
PyObject *GLUerror = NULL;



#define PyErr_SetGLerror(code) PyErr_SetObject(GLerror, Py_BuildValue("is", code, gluErrorString(code)));
#define PyErr_SetGLUerror(code) PyErr_SetObject(GLUerror, Py_BuildValue("is", code, gluErrorString(code)));

int _PyObject_Dimension(PyObject* x, int rank);

#define ERROR_MSG_SEP ", "
#define ERROR_MSG_SEP_LEN 2

int GLErrOccurred()
{
	if (PyErr_Occurred()) return 1;

	if (CurrentContextIsValid())
	{
		GLenum error, *errors = NULL;
		char *msg = NULL;
		const char *this_msg;
		int count = 0;
	
		error = glGetError();

		while (error != GL_NO_ERROR)
		{
			this_msg = gluErrorString(error);
			if (count)
			{
				msg = realloc(msg, (strlen(msg) + strlen(this_msg) + ERROR_MSG_SEP_LEN + 1)*sizeof(char));
				strcat(msg, ERROR_MSG_SEP);
				strcat(msg, this_msg);
				
				errors = realloc(errors, (count + 1)*sizeof(GLenum));
			}
			else
			{
				msg = malloc((strlen(this_msg) + 1)*sizeof(char));
				strcpy(msg, this_msg);
				
				errors = malloc(sizeof(GLenum));
			}
			
			errors[count++] = error;
			error = glGetError();
		}
		
		if (count)
		{
			PyErr_SetObject(GLerror, Py_BuildValue("Os", _PyTuple_FromIntArray(count, (int*)errors), msg));
			free(errors);
			free(msg);
			return 1;
		}
	}

	return 0;
}

void PyErr_SetGLErrorMessage( int id, char * message ) {
	/* set a GLerror with an ID and string message
	
	This tries pretty hard to look just like a regular
	error as produced by GLErrOccurred()'s formatter,
	save that there's only the single error being reported.

	Using id 0 is probably best for any future use where 
	there isn't a good match for the exception description
	in the error-enumeration set.
	 */
	PyObject * args = NULL;
	args = Py_BuildValue( "(i)s", id, message );
	if (args) {
		PyErr_SetObject( GLerror, args );
		Py_XDECREF( args );
	} else {
		PyErr_SetGLerror(id);
	}
}




#include <limits.h>


SWIGINTERN int
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
			const char *errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %ld is less than '%s' minimum %ld", 
		   value, errmsg, min_value);
    }
    return 0;    
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %ld is greater than '%s' maximum %ld", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_long(PyObject * obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("long", obj);
  }
  return 0;
 }


#if INT_MAX != LONG_MAX
SWIGINTERN int
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = (int)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT int
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGINTERNSHORT int
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_int(PyObject* obj)
{
  return SWIG_AsVal_int(obj, (int*)0);
}

 static char _doc_glArrayElement[] = "glArrayElement(i) -> None"; 

SWIGINTERNSHORT int
  SWIG_CheckUnsignedLongInRange(unsigned long value,
				unsigned long max_value,
				const char *errmsg) 
{
  if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %lu is greater than '%s' minimum %lu",
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
 }


SWIGINTERN int
  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
{
  if (PyInt_Check(obj)) {
    long v = PyInt_AS_LONG(obj);
    if (v >= 0) {
      if (val) *val = v;
      return 1;
    }   
  }
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  } 
  if (val) {
    SWIG_type_error("unsigned long", obj);
  }
  return 0;
}


#if UINT_MAX != ULONG_MAX
SWIGINTERN int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{ 
  const char* errmsg = val ? "unsigned int" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
      if (val) *val = (unsigned int)(v);
      return 1;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT unsigned int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{
  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
}
#endif


SWIGINTERNSHORT unsigned int
SWIG_As_unsigned_SS_int(PyObject* obj)
{
  unsigned int v;
  if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_int(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
}

 static char _doc_glBegin[] = "glBegin(mode) -> None"; 
 static char _doc_glCallList[] = "glCallList(list) -> None"; 
 static char _doc_glCallLists[] = "glCallLists(lists[]) -> None"; 

SWIGINTERN int
  SWIG_AsVal_signed_SS_char(PyObject *obj, signed char *val)
{
  const char* errmsg = val ? "signed char" : (char*) 0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, SCHAR_MIN, SCHAR_MAX, errmsg)) {
      if (val) *val = (signed char)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }  
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}

  
SWIGINTERNSHORT int
SWIG_Check_signed_SS_char(PyObject* obj)
{
  return SWIG_AsVal_signed_SS_char(obj, (signed char*)0);
}

 static char _doc_glColor3b[] = "glColor3b(red, green, blue) -> None"; 
 static char _doc_glColor3bv[] = "glColor3bv(v) -> None"; 

SWIGINTERN int
  SWIG_AsVal_double(PyObject *obj, double *val)
{
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AS_DOUBLE(obj);
    return 1;
  }  
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("double", obj);
  }
  return 0;
}


SWIGINTERNSHORT double
SWIG_As_double(PyObject* obj)
{
  double v;
  if (!SWIG_AsVal_double(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(double));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_double(PyObject* obj)
{
  return SWIG_AsVal_double(obj, (double*)0);
}

 static char _doc_glColor3d[] = "glColor3d(red, green, blue) -> None"; 
 static char _doc_glColor3dv[] = "glColor3dv(v) -> None"; 

#include <float.h>
SWIGINTERN int
  SWIG_CheckDoubleInRange(double value, double min_value, 
			  double max_value, const char* errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %g is less than %s minimum %g", 
		   value, errmsg, min_value);
    }
    return 0;
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %g is greater than %s maximum %g", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_float(PyObject *obj, float *val)
{
  const char* errmsg = val ? "float" : (char*)0;
  double v;
  if (SWIG_AsVal_double(obj, &v)) {
    if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
      if (val) *val = (float)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}


SWIGINTERNSHORT float
SWIG_As_float(PyObject* obj)
{
  float v;
  if (!SWIG_AsVal_float(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(float));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_float(PyObject* obj)
{
  return SWIG_AsVal_float(obj, (float*)0);
}

 static char _doc_glColor3f[] = "glColor3f(red, green, blue) -> None"; 
 static char _doc_glColor3fv[] = "glColor3fv(v) -> None"; 
 static char _doc_glColor3i[] = "glColor3i(red, green, blue) -> None"; 
 static char _doc_glColor3iv[] = "glColor3iv(v) -> None"; 

SWIGINTERN int
  SWIG_AsVal_short(PyObject *obj, short *val)
{ 
  const char* errmsg = val ? "short" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
      if (val) *val = (short)(v);
      return 1;
    } else {
      return 0;
    }    
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}

  
SWIGINTERNSHORT int
SWIG_Check_short(PyObject* obj)
{
  return SWIG_AsVal_short(obj, (short*)0);
}

 static char _doc_glColor3s[] = "glColor3s(red, green, blue) -> None"; 
 static char _doc_glColor3sv[] = "glColor3sv(v) -> None"; 

SWIGINTERN int
  SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
{ 
  const char* errmsg = val ? "unsigned char" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
      if (val) *val = (unsigned char)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_char(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
}

 static char _doc_glColor3ub[] = "glColor3ub(red, green, blue) -> None"; 
 static char _doc_glColor3ubv[] = "glColor3ubv(v) -> None"; 
 static char _doc_glColor3ui[] = "glColor3ui(red, green, blue) -> None"; 
 static char _doc_glColor3uiv[] = "glColor3uiv(v) -> None"; 

SWIGINTERN int
  SWIG_AsVal_unsigned_SS_short(PyObject *obj, unsigned short *val)
{ 
  const char* errmsg = val ? "unsigned short" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, USHRT_MAX, errmsg)) {
      if (val) *val = (unsigned short)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}


SWIGINTERNSHORT unsigned short
SWIG_As_unsigned_SS_short(PyObject* obj)
{
  unsigned short v;
  if (!SWIG_AsVal_unsigned_SS_short(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned short));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_short(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_short(obj, (unsigned short*)0);
}

 static char _doc_glColor3us[] = "glColor3us(red, green, blue) -> None"; 
 static char _doc_glColor3usv[] = "glColor3usv(v) -> None"; 
 static char _doc_glColor4b[] = "glColor4b(red, green, blue) -> None"; 
 static char _doc_glColor4bv[] = "glColor4bv(v) -> None"; 
 static char _doc_glColor4d[] = "glColor4d(red, green, blue) -> None"; 
 static char _doc_glColor4dv[] = "glColor4dv(v) -> None"; 
 static char _doc_glColor4f[] = "glColor4f(red, green, blue) -> None"; 
 static char _doc_glColor4fv[] = "glColor4fv(v) -> None"; 
 static char _doc_glColor4i[] = "glColor4i(red, green, blue) -> None"; 
 static char _doc_glColor4iv[] = "glColor4iv(v) -> None"; 
 static char _doc_glColor4s[] = "glColor4s(red, green, blue) -> None"; 
 static char _doc_glColor4sv[] = "glColor4sv(v) -> None"; 
 static char _doc_glColor4ub[] = "glColor4ub(red, green, blue) -> None"; 
 static char _doc_glColor4ubv[] = "glColor4ubv(v) -> None"; 
 static char _doc_glColor4ui[] = "glColor4ui(red, green, blue) -> None"; 
 static char _doc_glColor4uiv[] = "glColor4uiv(v) -> None"; 
 static char _doc_glColor4us[] = "glColor4us(red, green, blue) -> None"; 
 static char _doc_glColor4usv[] = "glColor4usv(v) -> None"; 
 static char _doc_glEdgeFlag[] = "glEdgeFlag(flag) -> None"; 
 static char _doc_glEdgeFlagv[] = "glEdgeFlagv(flag) -> None"; 
 static char _doc_glEvalCoord1d[] = "glEvalCoord1d(u) -> None"; 
 static char _doc_glEvalCoord1dv[] = "glEvalCoord1dv(v) -> None"; 
 static char _doc_glEvalCoord1f[] = "glEvalCoord1f(u) -> None"; 
 static char _doc_glEvalCoord1fv[] = "glEvalCoord1fv(v) -> None"; 
 static char _doc_glEvalCoord2d[] = "glEvalCoord2d(u, v) -> None"; 
 static char _doc_glEvalCoord2dv[] = "glEvalCoord2dv(v) -> None"; 
 static char _doc_glEvalCoord2f[] = "glEvalCoord2f(u, v) -> None"; 
 static char _doc_glEvalCoord2fv[] = "glEvalCoord2fv(v) -> None"; 
 static char _doc_glEvalPoint1[] = "glEvalPoint1(i) -> None"; 
 static char _doc_glEvalPoint2[] = "glEvalPoint2(i, j) -> None"; 
 static char _doc_glIndexd[] = "glIndexd(c) -> None"; 
 static char _doc_glIndexdv[] = "glIndexdv(c) -> None"; 
 static char _doc_glIndexf[] = "glIndexf(d) -> None"; 
 static char _doc_glIndexfv[] = "glIndexfv(c) -> None"; 
 static char _doc_glIndexi[] = "glIndexi(c) -> None"; 
 static char _doc_glIndexiv[] = "glIndexiv(c) -> None"; 
 static char _doc_glIndexs[] = "glIndexs(c) -> None"; 
 static char _doc_glIndexsv[] = "glIndexsv(c) -> None"; 
 static char _doc_glIndexub[] = "glIndexub(c) -> None"; 
 static char _doc_glIndexubv[] = "glIndexubv(c) -> None"; 
 static char _doc_glMaterialf[] = "glMaterialf(face, pname, param) -> None"; 
 static char _doc_glMaterialfv[] = "glMaterialfv(face, pname, params[]) -> None"; 
 static char _doc_glMateriali[] = "glMateriali(face, pname, param) -> None"; 
 static char _doc_glMaterialiv[] = "glMaterialiv(face, pname, params[]) -> None"; 
 static char _doc_glNormal3b[] = "glNormal3b(nx, ny, nz) -> None"; 
 static char _doc_glNormal3bv[] = "glNormal3bv(v) -> None"; 
 static char _doc_glNormal3d[] = "glNormal3d(nx, ny, nz) -> None"; 
 static char _doc_glNormal3dv[] = "glNormal3dv(v) -> None"; 
 static char _doc_glNormal3f[] = "glNormal3f(nx, ny, nz) -> None"; 
 static char _doc_glNormal3fv[] = "glNormal3fv(v) -> None"; 
 static char _doc_glNormal3i[] = "glNormal3i(nx, ny, nz) -> None"; 
 static char _doc_glNormal3iv[] = "glNormal3iv(v) -> None"; 
 static char _doc_glNormal3s[] = "glNormal3s(nx, ny, nz) -> None"; 
 static char _doc_glNormal3sv[] = "glNormal3sv(v) -> None"; 
 static char _doc_glTexCoord1d[] = "glTexCoord1d(s) -> None"; 
 static char _doc_glTexCoord1dv[] = "glTexCoord1dv(v) -> None"; 
 static char _doc_glTexCoord1f[] = "glTexCoord1f(s) -> None"; 
 static char _doc_glTexCoord1fv[] = "glTexCoord1fv(v) -> None"; 
 static char _doc_glTexCoord1i[] = "glTexCoord1i(s) -> None"; 
 static char _doc_glTexCoord1iv[] = "glTexCoord1iv(v) -> None"; 
 static char _doc_glTexCoord1s[] = "glTexCoord1s(s) -> None"; 
 static char _doc_glTexCoord1sv[] = "glTexCoord1sv(v) -> None"; 
 static char _doc_glTexCoord2d[] = "glTexCoord2d(s, t) -> None"; 
 static char _doc_glTexCoord2dv[] = "glTexCoord2dv(v) -> None"; 
 static char _doc_glTexCoord2f[] = "glTexCoord2f(s, t) -> None"; 
 static char _doc_glTexCoord2fv[] = "glTexCoord2fv(v) -> None"; 
 static char _doc_glTexCoord2i[] = "glTexCoord2i(s, t) -> None"; 
 static char _doc_glTexCoord2iv[] = "glTexCoord2iv(v) -> None"; 
 static char _doc_glTexCoord2s[] = "glTexCoord2s(s, t) -> None"; 
 static char _doc_glTexCoord2sv[] = "glTexCoord2sv(v) -> None"; 
 static char _doc_glTexCoord3d[] = "glTexCoord3d(s, t, r) -> None"; 
 static char _doc_glTexCoord3dv[] = "glTexCoord3dv(v) -> None"; 
 static char _doc_glTexCoord3f[] = "glTexCoord3f(s, t, r) -> None"; 
 static char _doc_glTexCoord3fv[] = "glTexCoord3fv(v) -> None"; 
 static char _doc_glTexCoord3i[] = "glTexCoord3i(s, t, r) -> None"; 
 static char _doc_glTexCoord3iv[] = "glTexCoord3iv(v) -> None"; 
 static char _doc_glTexCoord3s[] = "glTexCoord3s(s, t, r) -> None"; 
 static char _doc_glTexCoord3sv[] = "glTexCoord3sv(v) -> None"; 
 static char _doc_glTexCoord4d[] = "glTexCoord4d(s, t, r, q) -> None"; 
 static char _doc_glTexCoord4dv[] = "glTexCoord4dv(v) -> None"; 
 static char _doc_glTexCoord4f[] = "glTexCoord4f(s, t, r, q) -> None"; 
 static char _doc_glTexCoord4fv[] = "glTexCoord4fv(v) -> None"; 
 static char _doc_glTexCoord4i[] = "glTexCoord4i(s, t, r, q) -> None"; 
 static char _doc_glTexCoord4iv[] = "glTexCoord4iv(v) -> None"; 
 static char _doc_glTexCoord4s[] = "glTexCoord4s(s, t, r, q) -> None"; 
 static char _doc_glTexCoord4sv[] = "glTexCoord4sv(v) -> None"; 
 static char _doc_glVertex2d[] = "glVertex2d(x, y) -> None"; 
 static char _doc_glVertex2dv[] = "glVertex2dv(v) -> None"; 
 static char _doc_glVertex2f[] = "glVertex2f(x, y) -> None"; 
 static char _doc_glVertex2fv[] = "glVertex2fv(v) -> None"; 
 static char _doc_glVertex2i[] = "glVertex2i(x, y) -> None"; 
 static char _doc_glVertex2iv[] = "glVertex2iv(v) -> None"; 
 static char _doc_glVertex2s[] = "glVertex2s(x, y) -> None"; 
 static char _doc_glVertex2sv[] = "glVertex2sv(v) -> None"; 
 static char _doc_glVertex3d[] = "glVertex3d(x, y, z) -> None"; 
 static char _doc_glVertex3dv[] = "glVertex3dv(v) -> None"; 
 static char _doc_glVertex3f[] = "glVertex3f(x, y, z) -> None"; 
 static char _doc_glVertex3fv[] = "glVertex3fv(v) -> None"; 
 static char _doc_glVertex3i[] = "glVertex3i(x, y, z) -> None"; 
 static char _doc_glVertex3iv[] = "glVertex3iv(v) -> None"; 
 static char _doc_glVertex3s[] = "glVertex3s(x, y, z) -> None"; 
 static char _doc_glVertex3sv[] = "glVertex3sv(v) -> None"; 
 static char _doc_glVertex4d[] = "glVertex4d(x, y, z, w) -> None"; 
 static char _doc_glVertex4dv[] = "glVertex4dv(v) -> None"; 
 static char _doc_glVertex4f[] = "glVertex4f(x, y, z, w) -> None"; 
 static char _doc_glVertex4fv[] = "glVertex4fv(v) -> None"; 
 static char _doc_glVertex4i[] = "glVertex4i(x, y, z, w) -> None"; 
 static char _doc_glVertex4iv[] = "glVertex4iv(v) -> None"; 
 static char _doc_glVertex4s[] = "glVertex4s(x, y, z, w) -> None"; 
 static char _doc_glVertex4sv[] = "glVertex4sv(v) -> None"; 

/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
{
  static swig_type_info* pchar_info = 0;
  char* vptr = 0;
  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
    if (cptr) *cptr = vptr;
    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
    return SWIG_OLDOBJ;
  } else {
    PyErr_Clear();
    if (PyString_Check(obj)) {
      if (cptr) {
	*cptr = PyString_AS_STRING(obj);
	if (psize) {
	  *psize = PyString_GET_SIZE(obj) + 1;
	}
      }
      return SWIG_PYSTR;
    }
  }
  if (cptr) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}


SWIGINTERNSHORT int
SWIG_AsCharPtr(PyObject *obj, char **val)
{
  char* cptr = 0;
  if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) {
    if (val) *val = cptr;
    return 1;
  }
  if (val) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}

 static char _doc___has_extension[] = "Private function:  use appropriate extension initialization function instead."; 
 static char _doc_glAccum[] = "glAccum(op, value) -> None"; 
 static char _doc_glAlphaFunc[] = "glAlphaFunc(func, ref) -> None"; 

PyObject* _glAreTexturesResident(GLsizei n, const GLuint *textures)
{
	GLboolean *residences = PyMem_New(GLboolean, n);
	PyObject *result;
	
	glAreTexturesResident(n, textures, residences);
	result = _PyTuple_FromUnsignedCharArray(n, residences);
	
	PyMem_Del(residences);
	return result;
}

 static char _doc_glAreTexturesResident[] = "glAreTexturesResident(textures[]) -> residences"; 
 static char _doc_glBindTexture[] = "glBindTexture(target, texture) -> None"; 
 static char _doc_glBitmap[] = "glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap) -> None"; 
 static char _doc_glBlendFunc[] = "glBlendFunc(sfactor, dfactor) -> None"; 
 static char _doc_glClear[] = "glClear(mask) -> None"; 
 static char _doc_glClearAccum[] = "glClearAccum(red, green, blue, alpha) -> None"; 
 static char _doc_glClearColor[] = "glClearColor(red, green, blue, alpha) -> None"; 
 static char _doc_glClearDepth[] = "glClearDepth(depth) -> None"; 
 static char _doc_glClearIndex[] = "glClearIndex(c) -> None"; 
 static char _doc_glClearStencil[] = "glClearStencil(s) -> None"; 
 static char _doc_glClipPlane[] = "glClipPlane(plane, equation[]) -> None"; 
 static char _doc_glColorMask[] = "glColorMask(red, gree, blue, alpha) -> None"; 
 static char _doc_glColorMaterial[] = "glColorMaterial(face, mode) -> None"; 
 static char _doc_glCopyPixels[] = "glCopyPixels(x, y, width, height, type) -> None"; 
 static char _doc_glCopyTexImage1D[] = "glCopyTexImage1D(target, level, internalFormat, x, y, width, border) -> None"; 
 static char _doc_glCopyTexImage2D[] = "glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border) -> None"; 
 static char _doc_glCopyTexSubImage1D[] = "glCopyTexSubImage1D(target, level, xoffset, x, y, width) -> None"; 
 static char _doc_glCopyTexSubImage2D[] = "glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) -> None"; 
 static char _doc_glCullFace[] = "glCullFace(mode) -> None"; 
 static char _doc_glDeleteLists[] = "glDeleteLists(list, range) -> None"; 
 static char _doc_glDeleteTextures[] = "glDeleteTextures(textures[]) -> None"; 
 static char _doc_glDepthFunc[] = "glDepthFunc(func) -> None"; 
 static char _doc_glDepthMask[] = "glDepthMask(flag) -> None"; 
 static char _doc_glDepthRange[] = "glDepthRange(zNear, zFar) -> None"; 
 static char _doc_glDisable[] = "glDisable(cap) -> None"; 
 static char _doc_glDisableClientState[] = "glDisableClientState(array) -> None"; 
 static char _doc_glDrawBuffer[] = "glDrawBuffer(mode) -> None"; 
 static char _doc_glDrawPixels[] = "glDrawPixels(width, height, format, type, pixels) -> None"; 

void _glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
{
	SetupPixelWrite(2);
	glDrawPixels(width, height, format, type, pixels);
}

 static char _doc_glDrawPixelsub[] = "glDrawPixelsub(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelsb[] = "glDrawPixelsb(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelsus[] = "glDrawPixelsus(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelss[] = "glDrawPixelss(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelsui[] = "glDrawPixelsui(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelsi[] = "glDrawPixelsi(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glDrawPixelsf[] = "glDrawPixelsf(format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glEnable[] = "glEnable(cap) -> None"; 
 static char _doc_glEnableClientState[] = "glEnableClientState(array) -> None"; 
 static char _doc_glEnd[] = "glEnd() -> None"; 
 static char _doc_glEndList[] = "glEndList() -> None"; 
 static char _doc_glEvalMesh1[] = "glEvalMesh1(mode, i1, i2) -> None"; 
 static char _doc_glEvalMesh2[] = "glEvalMesh2(mode, i1, i2, j1, j2) -> None"; 


static GLfloat null_feedback_buffer[1];
void _glFeedbackBuffer(GLsizei size, GLenum type)
{
	GLfloat *buffer = (size > 0) ? PyMem_New(GLfloat, size) : null_feedback_buffer;
#ifndef GL_VERSION_1_1
	PyGLcontext *context = GetGLcontext();
	context->feedback_type = type;
	context->feedback_buffer = buffer;
#endif
	glFeedbackBuffer(size, type, buffer);
}

 static char _doc_glFeedbackBuffer[] = "glFeedbackBuffer(size, type) -> None"; 
 static char _doc_glFinish[] = "glFinish() -> None"; 
 static char _doc_glFlush[] = "glFlush() -> None"; 
 static char _doc_glFogf[] = "glFogf(pname, param) -> None"; 
 static char _doc_glFogfv[] = "glFogfv(pname, params[]) -> None"; 
 static char _doc_glFogi[] = "glFogi(pname, param) -> None"; 
 static char _doc_glFogiv[] = "glFogiv(pname, params[]) -> None"; 
 static char _doc_glFrontFace[] = "glFrontFace(mode) -> None"; 
 static char _doc_glFrustum[] = "glFrustum(left, right, bottom, top, zNear, zFar) -> None"; 

  /*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_long PyInt_FromLong
/*@@*/


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


#if UINT_MAX < LONG_MAX
/*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_int SWIG_From_long
/*@@*/
#else
/*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
/*@@*/
#endif

 static char _doc_glGenLists[] = "glGenLists(range) -> listBase"; 

PyObject* _glGenTextures(GLsizei n)
{
	GLuint* textures;
	PyObject* result;
	
	textures = PyMem_New(GLuint, n);
	glGenTextures(n, textures);
	result = _PyTuple_FromUnsignedIntArray(n, textures);

	PyMem_Del(textures);
	return result;
}

 static char _doc_glGenTextures[] = "glGenTextures(n) -> textures"; 
 static char _doc_glGetBooleanv[] = "glGetBooleanv(pname) -> params"; 
 static char _doc_glGetClipPlane[] = "glGetClipPlane(plane) -> equation"; 
 static char _doc_glGetDoublev[] = "glGetDoublev(pname) -> params"; 
 static char _doc_glGetFloatv[] = "glGetFloatv(pname) -> params"; 
 static char _doc_glGetIntegerv[] = "glGetIntegerv(pname) -> params"; 
 static char _doc_glGetLightfv[] = "glGetLightfv(light, pname) -> params"; 
 static char _doc_glGetLightiv[] = "glGetLightiv(light, pname) -> params"; 

int _calcMapSizes(GLenum target, GLenum query, int *dimension, int *cp_size, int *v_size, int order[2])
{
	switch (target)
	{
	case GL_MAP1_INDEX:
	case GL_MAP1_TEXTURE_COORD_1:
		*dimension = 1;
		*cp_size = 1;
		break;
	case GL_MAP1_TEXTURE_COORD_2:
		*dimension = 1;
		*cp_size = 2;
		break;
	case GL_MAP1_NORMAL:
	case GL_MAP1_TEXTURE_COORD_3:
	case GL_MAP1_VERTEX_3:
		*dimension = 1;
		*cp_size = 3;
		break;
	case GL_MAP1_COLOR_4:
	case GL_MAP1_TEXTURE_COORD_4:
	case GL_MAP1_VERTEX_4:
		*dimension = 1;
		*cp_size = 4;
		break;
	case GL_MAP2_INDEX:
	case GL_MAP2_TEXTURE_COORD_1:
		*dimension = 2;
		*cp_size = 1;
		break;
	case GL_MAP2_TEXTURE_COORD_2:
		*dimension = 2;
		*cp_size = 2;
		break;
	case GL_MAP2_NORMAL:
	case GL_MAP2_TEXTURE_COORD_3:
	case GL_MAP2_VERTEX_3:
		*dimension = 2;
		*cp_size = 3;
		break;
	case GL_MAP2_COLOR_4:
	case GL_MAP2_TEXTURE_COORD_4:
	case GL_MAP2_VERTEX_4:
		*dimension = 2;
		*cp_size = 4;
		break;
	default:
		PyErr_SetString(PyExc_Exception, "Unknown target.");
		return 0;
	}

	switch (query)
	{
	case GL_COEFF:
		glGetMapiv(target, GL_ORDER, order);
		*v_size = (*cp_size)*order[0]*((*dimension == 2) ? order[1] : 1);
		break;
	case GL_ORDER:
		*v_size = *dimension;
		break;
	case GL_DOMAIN:
		*v_size = 2*(*dimension);
		break;
	default:
		PyErr_SetString(PyExc_Exception, "Unknown query.");
		return 0;
	}
	
	return 1;
}


 PyObject* _glGetMapdv(GLenum target, GLenum query) { 	int dimension, cp_size, v_size; 	GLint order[2]; 	double* v; 	PyObject* result; 	int dims[3];  	if (!_calcMapSizes(target, query, &dimension, &cp_size, &v_size, order)) return NULL;  	v = PyMem_New(double, v_size); 	glGetMapdv(target, query, v);  	if (query == GL_COEFF) 	{ 		if (dimension == 2) 		{ 			dims[0] = order[1]; 			dims[1] = order[0]; 			dims[2] = cp_size; 		} 		else 		{ 			dims[0] = order[0]; 			dims[1] = cp_size; 		} 		result = _PyObject_FromDoubleArray(dimension + 1, dims, v, 1); 	} 	else 	{ 		result = _PyTuple_FromDoubleArray(v_size, v); 		PyMem_Del(v); 	}  	return result; } 
 PyObject* _glGetMapfv(GLenum target, GLenum query) { 	int dimension, cp_size, v_size; 	GLint order[2]; 	float* v; 	PyObject* result; 	int dims[3];  	if (!_calcMapSizes(target, query, &dimension, &cp_size, &v_size, order)) return NULL;  	v = PyMem_New(float, v_size); 	glGetMapfv(target, query, v);  	if (query == GL_COEFF) 	{ 		if (dimension == 2) 		{ 			dims[0] = order[1]; 			dims[1] = order[0]; 			dims[2] = cp_size; 		} 		else 		{ 			dims[0] = order[0]; 			dims[1] = cp_size; 		} 		result = _PyObject_FromFloatArray(dimension + 1, dims, v, 1); 	} 	else 	{ 		result = _PyTuple_FromFloatArray(v_size, v); 		PyMem_Del(v); 	}  	return result; } 
 PyObject* _glGetMapiv(GLenum target, GLenum query) { 	int dimension, cp_size, v_size; 	GLint order[2]; 	int* v; 	PyObject* result; 	int dims[3];  	if (!_calcMapSizes(target, query, &dimension, &cp_size, &v_size, order)) return NULL;  	v = PyMem_New(int, v_size); 	glGetMapiv(target, query, v);  	if (query == GL_COEFF) 	{ 		if (dimension == 2) 		{ 			dims[0] = order[1]; 			dims[1] = order[0]; 			dims[2] = cp_size; 		} 		else 		{ 			dims[0] = order[0]; 			dims[1] = cp_size; 		} 		result = _PyObject_FromIntArray(dimension + 1, dims, v, 1); 	} 	else 	{ 		result = _PyTuple_FromIntArray(v_size, v); 		PyMem_Del(v); 	}  	return result; } 
 static char _doc_glGetMapdv[] = "glGetMapdv(target, query) -> values"; 
 static char _doc_glGetMapfv[] = "glGetMapfv(target, query) -> values"; 
 static char _doc_glGetMapiv[] = "glGetMapiv(target, query) -> values"; 
 static char _doc_glGetMaterialfv[] = "glGetMaterialfv(face, pname) -> params"; 
 static char _doc_glGetMaterialiv[] = "glGetMaterialiv(face, pname) -> params"; 
 PyObject* _glGetPixelMapfv(GLenum map) { 	int i; 	GLint size; 	GLfloat* values; 	PyObject* result;  	glGetIntegerv(GL_PIXEL_MAP_I_TO_I_SIZE - GL_PIXEL_MAP_I_TO_I + map, &size); 	values = PyMem_New(GLfloat, size); 	glGetPixelMapfv(map, values);  	result = PyTuple_New(size); 	for (i = 0; i < size; i++) PyTuple_SetItem(result, i, PyFloat_FromDouble(values[i])); 	PyMem_Del(values);  	return result; } 
 PyObject* _glGetPixelMapuiv(GLenum map) { 	int i; 	GLint size; 	GLuint* values; 	PyObject* result;  	glGetIntegerv(GL_PIXEL_MAP_I_TO_I_SIZE - GL_PIXEL_MAP_I_TO_I + map, &size); 	values = PyMem_New(GLuint, size); 	glGetPixelMapuiv(map, values);  	result = PyTuple_New(size); 	for (i = 0; i < size; i++) PyTuple_SetItem(result, i, PyLong_FromUnsignedLong(values[i])); 	PyMem_Del(values);  	return result; } 
 PyObject* _glGetPixelMapusv(GLenum map) { 	int i; 	GLint size; 	GLushort* values; 	PyObject* result;  	glGetIntegerv(GL_PIXEL_MAP_I_TO_I_SIZE - GL_PIXEL_MAP_I_TO_I + map, &size); 	values = PyMem_New(GLushort, size); 	glGetPixelMapusv(map, values);  	result = PyTuple_New(size); 	for (i = 0; i < size; i++) PyTuple_SetItem(result, i, PyInt_FromLong(values[i])); 	PyMem_Del(values);  	return result; } 
 static char _doc_glGetPixelMapfv[] = "glGetPixelMapfv(map) -> values"; 
 static char _doc_glGetPixelMapuiv[] = "glGetPixelMapuiv(map) -> values"; 
 static char _doc_glGetPixelMapusv[] = "glGetPixelMapusv(map) -> values"; 

PyObject* _glGetPolygonStipple()
{
	PyObject* result;
	int size;
	GLint dims[] = {32, 32};
	void* data = SetupRawPixelRead(GL_BITMAP, GL_UNSIGNED_BYTE, 2, dims, &size);
	if (!data) return NULL;
	
	glGetPolygonStipple(data);
	result = PyString_FromStringAndSize((const char*)data, size);
	PyMem_Del(data);

	return result;
}

 static char _doc_glGetPolygonStipple[] = "glGetPolygonStipple() -> packed stipple"; 

PyObject* glGetPolygonStippleub()
{
	int dims[] = {32, 32};
	GLubyte packed[128];
	GLubyte unpacked[1024];
	int i, j;
	
	glPixelStorei(GL_PACK_SWAP_BYTES, 0);
	glPixelStorei(GL_PACK_LSB_FIRST, 1);

	glGetPolygonStipple(packed);
	
	for (i = 0; i < 128; i++) for (j = 0; j < 8; j++) unpacked[8*i + j] = (packed[i] >> j) & 1;
	
	return _PyObject_FromUnsignedCharArray(2, dims, unpacked, 0);
}

 static char _doc_glGetPolygonStippleub[] = "glGetPolygonStippleub() -> stipple[][]"; 
 static char _doc_glGetString[] = "glGetString(name) -> string"; 
 static char _doc_glGetTexEnvfv[] = "glGetTexEnvfv(target, pname) -> params"; 
 static char _doc_glGetTexEnviv[] = "glGetTexEnviv(target, pname) -> params"; 
 static char _doc_glGetTexGendv[] = "glGetTexGendv(coord, pname) -> params"; 
 static char _doc_glGetTexGenfv[] = "glGetTexGenfv(coord, pname) -> params"; 
 static char _doc_glGetTexGeniv[] = "glGetTexGeniv(coord, pname) -> params"; 

#ifndef GL_SGIS_texture4D
#define GL_TEXTURE_4D_SGIS                0x8134
#define GL_TEXTURE_4DSIZE_SGIS            0x8136
#endif

#ifndef GL_VERSION_1_2
#define GL_TEXTURE_3D				0x806F
#define GL_TEXTURE_DEPTH			0x8071
#endif

/* figure out the rank of the image and the dimensions */
int get_tex_dims(GLenum target, GLint level, int dims[4])
{
	int rank = 0;

	/* just cascade through the switch, retrieving the apropriate sizes */
	switch (target)
	{
	case GL_TEXTURE_4D_SGIS:
		glGetTexLevelParameteriv(target, level, GL_TEXTURE_4DSIZE_SGIS, dims + rank++);
	case GL_TEXTURE_3D:
		glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, dims + rank++);
	case GL_TEXTURE_2D:
		glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, dims + rank++);
	case GL_TEXTURE_1D:
		glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, dims + rank++);
	}
	return rank;
}

PyObject* _glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type)
{
	PyObject* result;
	int size;
	GLint dims[4];
	int rank;
	void* data = NULL;
	
	rank = get_tex_dims(target, level, dims);
	
	/* dims[rank] is set to the appropriate value for format here */
	data = SetupRawPixelRead(format, type, rank, dims, &size);
	if (!data) return NULL;
	
	glGetTexImage(target, level, format, type, data);
	result = PyString_FromStringAndSize((const char*)data, size);
	PyMem_Del(data);

	return result;
}

 static char _doc_glGetTexImage[] = "glGetTexImage(target, level, format, type) -> pixels"; 

PyObject* __glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type)
{
	int dims[5], rank;
	void* data;
	

	rank = get_tex_dims(target, level, dims);
	
	/* dims[rank] is set to the appropriate value for format here */
	data = SetupPixelRead(rank, format, type, dims);
	if (!data) return NULL;
	
	glGetTexImage(target, level, format, type, data);

	/* Note need to add one
		rank will be used as "nd" (number of dimensions),
		for constructing the array. _PyObject_FromArray counts
		from 1 for this parameter
	*/
	return _PyObject_FromArray(type, (dims[rank] == 1) ? rank : rank+1, dims, data, 1);
}

 static char _doc_glGetTexImageub[] = "glGetTexImageub(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImageb[] = "glGetTexImageb(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImageus[] = "glGetTexImageus(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImages[] = "glGetTexImages(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImageui[] = "glGetTexImageui(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImagei[] = "glGetTexImagei(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImagef[] = "glGetTexImagef(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexImaged[] = "glGetTexImagef(target, level, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glGetTexLevelParameterfv[] = "glGetTexLevelParameterfv(target, level, pname) -> params"; 
 static char _doc_glGetTexLevelParameteriv[] = "glGetTexLevelParameteriv(target, level, pname) -> params"; 
 static char _doc_glGetTexParameterfv[] = "glGetTexParameterfv(target, pname) -> params"; 
 static char _doc_glGetTexParameteriv[] = "glGetTexParameteriv(target, pname) -> params"; 
 static char _doc_glHint[] = "glHint(target, mode) -> None"; 
 static char _doc_glIndexMask[] = "glIndexMask(mask) -> None"; 
 static char _doc_glInitNames[] = "glInitNames() -> None"; 

  /*@C:\\bin\\SWIG-1.3.23\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_char PyInt_FromLong
/*@@*/

 static char _doc_glIsEnabled[] = "glIsEnabled(cap) -> None"; 
 static char _doc_glIsList[] = "glIsList(list) -> boolean"; 
 static char _doc_glIsTexture[] = "glIsTexture(texture) -> boolean"; 
 static char _doc_glLightModelf[] = "glLightModelf(pname, param) -> None"; 
 static char _doc_glLightModelfv[] = "glLightModelfv(pname, params) -> None"; 
 static char _doc_glLightModeli[] = "glLightModeli(pname, param) -> None"; 
 static char _doc_glLightModeliv[] = "glLightModeliv(pname, params) -> None"; 
 static char _doc_glLightf[] = "glLightf(light, pname, param) -> None"; 
 static char _doc_glLightfv[] = "glLightfv(light, pname, params) -> None"; 
 static char _doc_glLighti[] = "glLighti(light, pname, param) -> None"; 
 static char _doc_glLightiv[] = "glLightiv(light, pname, params) -> None"; 
 static char _doc_glLineStipple[] = "glLineStipple(factor, pattern) -> None"; 
 static char _doc_glLineWidth[] = "glLineWidth(width) -> None"; 
 static char _doc_glListBase[] = "glListBase(base) -> None"; 
 static char _doc_glLoadIdentity[] = "glLoadIdentity() -> None"; 
 static char _doc_glLoadMatrixd[] = "glLoadMatrixd(matrix) -> None"; 
 static char _doc_glLoadMatrixf[] = "glLoadMatrixf(matrix) -> None"; 
 static char _doc_glLoadName[] = "glLoadName(name) -> None"; 
 static char _doc_glLogicOp[] = "glLogicOp(opcode) -> None"; 
 static char _doc_glMap1d[] = "glMap1d(target, u1, u2, points[][]) -> None"; 
 static char _doc_glMap1f[] = "glMap1f(target, u1, u2, points[][]) -> None"; 

#define _glMap2d(target, u1, u2, uorder, v1, v2, vstride, vorder, points) glMap2d(target, u1, u2, vstride*vorder, uorder, v1, v2, vstride, vorder, points) 

 static char _doc_glMap2d[] = "glMap2d(target, u1, u2, v1, v2, points[][][]) -> None"; 

#define _glMap2f(target, u1, u2, uorder, v1, v2, vstride, vorder, points) glMap2f(target, u1, u2, vstride*vorder, uorder, v1, v2, vstride, vorder, points) 

 static char _doc_glMap2f[] = "glMap2f(target, u1, u2, v1, v2, points[][][]) -> None"; 
 static char _doc_glMapGrid1d[] = "glMapGrid1d(un, u1, u2) -> None"; 
 static char _doc_glMapGrid1f[] = "glMapGrid1f(un, u1, u2) -> None"; 
 static char _doc_glMapGrid2d[] = "glMapGrid2d(un, u1, u2, vn, v1, v2) -> None"; 
 static char _doc_glMapGrid2f[] = "glMapGrid2f(un, u1, u2, vn, v1, v2) -> None"; 
 static char _doc_glMatrixMode[] = "glMatrixMode(mode) -> None"; 
 static char _doc_glMultMatrixd[] = "glMultMatrixd(v) -> None"; 
 static char _doc_glMultMatrixf[] = "glMultMatrixf(v) -> None"; 
 static char _doc_glNewList[] = "glNewList(list, mode) -> None"; 
 static char _doc_glOrtho[] = "glOrtho(left, right, bottom, top, zNear, zFar) -> None"; 
 static char _doc_glPassThrough[] = "glPassThrough(token) -> None"; 
 static char _doc_glPixelMapfv[] = "glPixelMapfv(map, values) -> None"; 
 static char _doc_glPixelMapuiv[] = "glPixelMapuiv(map, values) -> None"; 
 static char _doc_glPixelMapusv[] = "glPixelMapusv(map, values) -> None"; 
 static char _doc_glPixelStoref[] = "glPixelStoref(pname, param) -> None"; 
 static char _doc_glPixelStorei[] = "glPixelStorei(pname, param) -> None"; 
 static char _doc_glPixelTransferf[] = "glPixelTransferf(name, param) -> None"; 
 static char _doc_glPixelTransferi[] = "glPixelTransferi(name, param) -> None"; 
 static char _doc_glPixelZoom[] = "glPixelZoom(xfactor, yfactor) -> None"; 
 static char _doc_glPointSize[] = "glPointSize(size) -> None"; 
 static char _doc_glPolygonMode[] = "glPolygonMode(face, mode) -> None"; 
 static char _doc_glPolygonStipple[] = "glPolygonStipple(mask) -> None"; 

void glPolygonStippleub (const GLubyte *mask)
{
	GLubyte packed[128];
	int i, j;
	
	glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
	glPixelStorei(GL_UNPACK_LSB_FIRST, 1);

	for (i = 0; i < 128; i++)
	{
		packed[i] = 0;
		for (j = 0; j < 8; j++) packed[i] += mask[8*i + j] << j;
	}
	
	glPolygonStipple(packed);
}

 static char _doc_glPolygonStippleub[] = "glPolygonStippleub(mask[][]) -> None"; 
 static char _doc_glPopAttrib[] = "glPopAttrib() -> None"; 

void _glPopClientAttrib()
{
	decrementAllLocks();
	glPopClientAttrib();
}

 static char _doc_glPopClientAttrib[] = "glPopClientAttrib() -> None"; 
 static char _doc_glPopMatrix[] = "glPopMatrix() -> None"; 
 static char _doc_glPopName[] = "glPopName() -> None"; 
 static char _doc_glPrioritizeTextures[] = "glPrioritizeTextures(textures[], priorities[]) -> None"; 
 static char _doc_glPushAttrib[] = "glPushAttrib(mask) -> None"; 

#ifndef GL_CLIENT_VERTEX_ARRAY_BIT
#define GL_CLIENT_VERTEX_ARRAY_BIT        0x00000002
#endif

void _glPushClientAttrib (GLbitfield mask)
{
	mask |= GL_CLIENT_VERTEX_ARRAY_BIT;

	incrementAllLocks();
	glPushClientAttrib(mask);
}


 static char _doc_glPushClientAttrib[] = "glPushClientAttrib(mask) -> None"; 
 static char _doc_glPushMatrix[] = "glPushMatrix() -> None"; 
 static char _doc_glPushName[] = "glPushName(name) -> None"; 
 static char _doc_glRasterPos2d[] = "glRasterPos2d(x, y) -> None"; 
 static char _doc_glRasterPos2dv[] = "glRasterPos2dv(v) -> None"; 
 static char _doc_glRasterPos2f[] = "glRasterPos2f(x, y) -> None"; 
 static char _doc_glRasterPos2fv[] = "glRasterPos2fv(v) -> None"; 
 static char _doc_glRasterPos2i[] = "glRasterPos2i(x, y) -> None"; 
 static char _doc_glRasterPos2iv[] = "glRasterPos2iv(v) -> None"; 
 static char _doc_glRasterPos2s[] = "glRasterPos2s(x, y) -> None"; 
 static char _doc_glRasterPos2sv[] = "glRasterPos2sv(v) -> None"; 
 static char _doc_glRasterPos3d[] = "glRasterPos3d(x, y, z) -> None"; 
 static char _doc_glRasterPos3dv[] = "glRasterPos3dv(v) -> None"; 
 static char _doc_glRasterPos3f[] = "glRasterPos3f(x, y, z) -> None"; 
 static char _doc_glRasterPos3fv[] = "glRasterPos3fv(v) -> None"; 
 static char _doc_glRasterPos3i[] = "glRasterPos3i(x, y, z) -> None"; 
 static char _doc_glRasterPos3iv[] = "glRasterPos3iv(v) -> None"; 
 static char _doc_glRasterPos3s[] = "glRasterPos3s(x, y, z) -> None"; 
 static char _doc_glRasterPos3sv[] = "glRasterPos3sv(v) -> None"; 
 static char _doc_glRasterPos4d[] = "glRasterPos4d(x, y, z, w) -> None"; 
 static char _doc_glRasterPos4dv[] = "glRasterPos4dv(v) -> None"; 
 static char _doc_glRasterPos4f[] = "glRasterPos4f(x, y, z, w) -> None"; 
 static char _doc_glRasterPos4fv[] = "glRasterPos4fv(v) -> None"; 
 static char _doc_glRasterPos4i[] = "glRasterPos4i(x, y, z, w) -> None"; 
 static char _doc_glRasterPos4iv[] = "glRasterPos4iv(v) -> None"; 
 static char _doc_glRasterPos4s[] = "glRasterPos4s(x, y, z, w) -> None"; 
 static char _doc_glRasterPos4sv[] = "glRasterPos4sv(v) -> None"; 
 static char _doc_glReadBuffer[] = "glReadBuffer(mode) -> None"; 

PyObject* _glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type)
{
	PyObject* result;
	int size;
	GLint dims[2];
	void* data = NULL;
	
	dims[0] = width;
	dims[1] = height;
	data = SetupRawPixelRead(format, type, 2, dims, &size);
	if (!data) return NULL;
	
	glReadPixels(x, y, width, height, format, type, data);
	result = PyString_FromStringAndSize((const char*)data, size);
	PyMem_Del(data);

	return result;
}

 static char _doc_glReadPixels[] = "glReadPixels(x, y, width, height, format, type) -> pixels"; 

PyObject* __glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type)
{
	int dims[3];
	void* data;

	dims[0] = width;
	dims[1] = height;

	data = SetupPixelRead(2, format, type, dims);
	if (!data) return NULL;

	glReadPixels(x, y, width, height, format, type, data);
	
	return _PyObject_FromArray(type, (dims[2] == 1) ? 2 : 3, dims, data, 1);
}

 static char _doc_glReadPixelsub[] = "glReadPixelsub(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsb[] = "glReadPixelsb(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsus[] = "glReadPixelsus(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelss[] = "glReadPixelss(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsui[] = "glReadPixelsui(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsi[] = "glReadPixelsi(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsf[] = "glReadPixelsf(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glReadPixelsd[] = "glReadPixelsd(x, y, width, height, format) -> pixels[][] | pixels[][][]"; 
 static char _doc_glRectd[] = "glRectd(x1, y1, x2, y2) -> None"; 
 static char _doc_glRectdv[] = "glRectdv(p1, p2) -> None"; 
 static char _doc_glRectf[] = "glRectf(x1, y1, x2, y2) -> None"; 
 static char _doc_glRectfv[] = "glRectfv(p1, p2) -> None"; 
 static char _doc_glRecti[] = "glRecti(x1, y1, x2, y2) -> None"; 
 static char _doc_glRectiv[] = "glRectiv(p1, p2) -> None"; 
 static char _doc_glRects[] = "glRects(x1, y1, x2, y2) -> None"; 
 static char _doc_glRectsv[] = "glRectsv(p1, p2) -> None"; 

typedef struct
{
	PyObject_HEAD
	GLint count;
	GLint vertex_len;
	GLfloat* buffer;
	GLint* pos;
} PyFeedbackBuffer;


static int PyFeedbackBuffer_Length(PyObject *self)
{
	return ((PyFeedbackBuffer*)self)->count;
}


static PyObject *PyFeedbackBuffer_GetItem(PyObject *self, int i)
{
	PyObject *result;
	int pos, dims[2];
	GLenum token;
	GLint vertex_count;
	
	if (i < 0) i += ((PyFeedbackBuffer*)self)->count;

	/* Throw an exception if index is out of bounds */
	if (i < 0 || i >= ((PyFeedbackBuffer*)self)->count)
	{
		PyErr_SetString(PyExc_IndexError, "Index out of range.");
		return NULL;
	}
	pos = ((PyFeedbackBuffer*)self)->pos[i];

	result = PyTuple_New(2);
	PyTuple_SetItem(result, 0, PyLong_FromUnsignedLong(token = (GLenum)((PyFeedbackBuffer*)self)->buffer[pos++]));
	if (token == GL_PASS_THROUGH_TOKEN)
	{
		/* pass through has a single value */
		PyTuple_SetItem(result, 1, PyFloat_FromDouble(((PyFeedbackBuffer*)self)->buffer[pos]));
	}
	else
	{
		/* figure out how many vertices there are */
		switch (token)
		{
		case GL_POINT_TOKEN:
		case GL_BITMAP_TOKEN:
		case GL_DRAW_PIXEL_TOKEN:
		case GL_COPY_PIXEL_TOKEN:
			vertex_count = 1;
			break;
		case GL_LINE_TOKEN:
		case GL_LINE_RESET_TOKEN:
			vertex_count = 2;
			break;
		case GL_POLYGON_TOKEN:
			vertex_count = (GLint)((PyFeedbackBuffer*)self)->buffer[pos++];
			break;
		default:
			Py_DECREF(result);
			PyErr_SetString(PyExc_Exception, "Unknown token found in feedback buffer.");
			return NULL;
		}
		
		dims[0] = vertex_count;
		dims[1] = ((PyFeedbackBuffer*)self)->vertex_len;
		PyTuple_SetItem(result, 1, _PyObject_FromFloatArray(2, dims, ((PyFeedbackBuffer*)self)->buffer + pos, 0));
	}

	return result;
}


static void PyFeedbackBuffer_Del(PyObject *self)
{
	PyMem_Del(((PyFeedbackBuffer*)self)->buffer);
	PyMem_Del(((PyFeedbackBuffer*)self)->pos);
    PyObject_Del(self);
}


static PySequenceMethods PyFeedbackBuffer_SequenceMethods =
{
    PyFeedbackBuffer_Length,	/* sq_length */
    NULL,						/* nb_add */
    NULL,						/* nb_multiply */
    PyFeedbackBuffer_GetItem,	/* sq_item */
};


PyTypeObject PyFeedbackBuffer_Type =
{
    PyObject_HEAD_INIT(0)
    0,									/* ob_size */
    "FeedbackBuffer",					/* tp_name */
    sizeof(PyFeedbackBuffer),			/* tp_basicsize */
    0,									/* tp_itemsize */
    PyFeedbackBuffer_Del,				/* tp_dealloc */
    NULL,								/* tp_print */
    NULL,								/* tp_getattr */
    NULL,								/* tp_setattr */
    NULL,								/* tp_compare */
    NULL,								/* tp_repr */
    NULL,								/* tp_as_number */
    &PyFeedbackBuffer_SequenceMethods,	/* tp_as_sequence */
};


PyObject* PyFeedbackBuffer_New(GLint value_count)
{
	/* Initialise a Python-friendly Feedback-buffer wrapper
	
		glRenderMode returns length of the buffer not the number of 
		records  So value_count is the number of GLfloat values 
		currently in the buffer, it will always be a lower value 
		than that specified in the glFeedbackBuffer() call.
	*/
	int len;
	int color_len;
	int texture_len;
	GLboolean rgba_mode;
	GLenum type;
	PyFeedbackBuffer *result = PyObject_NEW(PyFeedbackBuffer, &PyFeedbackBuffer_Type);

	/* explicitly initialise just to be safe... */
	result->count = 0;
	result->vertex_len = 0;
	result->buffer = NULL;
	result->pos = NULL;
	
	/* Get the buffer type and color mode so we can calculate the length of a vertex */
#ifdef GL_VERSION_1_1
	glGetPointerv(GL_FEEDBACK_BUFFER_POINTER, (void**)&result->buffer);
	glGetIntegerv(GL_FEEDBACK_BUFFER_TYPE, (GLint*)&type);
#else
	PyGLcontext *context = GetGLcontext();
	result->buffer = context->feedback_buffer;
	type = context->feedback_type;
#endif
	glGetBooleanv(GL_RGBA_MODE, &rgba_mode);
	/* Stop anyone writing to the buffer we're wrapping 
	
		This is only necessary if something else is manipulating
		the feedback buffer (i.e. not PyOpenGL).
	*/
	glFeedbackBuffer(0, type, null_feedback_buffer);


	/* Calculate the length of a vertex */
	color_len = ((rgba_mode) ? 4 : 1);
	texture_len = 4;

	switch (type)
	{
	case GL_2D:
		result->vertex_len = 2;
		break;
	case GL_3D:
		result->vertex_len = 3;
		break;
	case GL_3D_COLOR:
		result->vertex_len = 3 + color_len;
		break;
	case GL_3D_COLOR_TEXTURE:
		result->vertex_len = 3 + color_len + texture_len;
		break;
	case GL_4D_COLOR_TEXTURE:
		result->vertex_len = 4 + color_len + texture_len;
		break;
	default:
		Py_DECREF(result);
		PyErr_SetString(PyExc_Exception, "Unknown vertex type in feedback buffer.");
		return NULL;
	}
	result->pos = PyMem_New(GLint, 1);
	/* Go through the buffer and find the position of each item */
	for (len = 0; len < value_count;)
	{
		result->count += 1;
		/* add new slot for position-entry */
		result->pos = PyMem_Resize(result->pos, GLint, result->count); 
		/* store current read-position */
		result->pos[result->count-1] = len;

		switch ((GLenum)result->buffer[len++])
		{
		case GL_POINT_TOKEN:
		case GL_BITMAP_TOKEN:
		case GL_DRAW_PIXEL_TOKEN:
		case GL_COPY_PIXEL_TOKEN:
			len += result->vertex_len;
			break;
		case GL_LINE_TOKEN:
		case GL_LINE_RESET_TOKEN:
			len += 2*result->vertex_len;
			break;
		case GL_POLYGON_TOKEN:
			len += (int)result->buffer[len++]*result->vertex_len;
			break;
		case GL_PASS_THROUGH_TOKEN:
			len++;
			break;
		default:
			Py_DECREF(result);
			PyErr_SetString(PyExc_Exception, "Unknown token found in feedback buffer.");
			return NULL;
		};
	}
	return (PyObject*)result;
}


typedef struct
{
	PyObject_HEAD
	GLint count;
	GLuint* buffer;
	GLint* pos;
} PySelectBuffer;


static int PySelectBuffer_Length(PyObject *self)
{
	return ((PySelectBuffer*)self)->count;
}


static PyObject *PySelectBuffer_GetItem(PyObject *self, int i)
{
	PyObject *result, *names;
	int pos,j;
	GLint name_count;
	
	if (i < 0) i += ((PySelectBuffer*)self)->count;

	/* Throw an exception if out of bounds */
	if (i < 0 || i >= ((PySelectBuffer*)self)->count)
	{
		PyErr_SetString(PyExc_IndexError, "Index out of range.");
		return NULL;
	}
	pos = ((PySelectBuffer*)self)->pos[i];

	/* Create the element */
	result = PyTuple_New(3);

	PyTuple_SetItem(result, 2, names = PyTuple_New(name_count = ((PySelectBuffer*)self)->buffer[pos++]));

	PyTuple_SetItem(result, 0, PyLong_FromUnsignedLong(((PySelectBuffer*)self)->buffer[pos++]));
	PyTuple_SetItem(result, 1, PyLong_FromUnsignedLong(((PySelectBuffer*)self)->buffer[pos++]));
		
	for (j = 0; j < name_count; j++, pos++) PyTuple_SetItem(names, j, PyLong_FromUnsignedLong(((PySelectBuffer*)self)->buffer[pos]));
	
	return result;
}


static void PySelectBuffer_Del(PyObject *self)
{
	PyMem_Del(((PySelectBuffer*)self)->buffer);
	PyMem_Del(((PySelectBuffer*)self)->pos);
    PyObject_Del(self);
}


static PySequenceMethods PySelectBuffer_SequenceMethods =
{
    PySelectBuffer_Length,		/* sq_length */
    NULL,						/* nb_add */
    NULL,						/* nb_multiply */
    PySelectBuffer_GetItem,		/* sq_item */
};


PyTypeObject PySelectBuffer_Type =
{
    PyObject_HEAD_INIT(0)
    0,									/* ob_size */
    "SelectBuffer",						/* tp_name */
    sizeof(PySelectBuffer),				/* tp_basicsize */
    0,									/* tp_itemsize */
    PySelectBuffer_Del,					/* tp_dealloc */
    NULL,								/* tp_print */
    NULL,								/* tp_getattr */
    NULL,								/* tp_setattr */
    NULL,								/* tp_compare */
    NULL,								/* tp_repr */
    NULL,								/* tp_as_number */
    &PySelectBuffer_SequenceMethods,	/* tp_as_sequence */
};

/* Work around for GL bug (Microsoft?) */
static GLuint null_select_buffer[1];


PyObject* PySelectBuffer_New(GLint count)
{
	int len, i;
	PySelectBuffer *result = PyObject_NEW(PySelectBuffer, &PySelectBuffer_Type);
	
#ifdef GL_VERSION_1_1
	glGetPointerv(GL_SELECTION_BUFFER_POINTER, (void**)&result->buffer);
#else
	PyGLcontext *context = GetGLcontext();
	result->buffer = context->selection_buffer;
	context->selection_buffer = null_select_buffer;
#endif
	glSelectBuffer(0, null_select_buffer);

	result->count = count;
	result->pos = PyMem_New(GLint, count);

	/* Go through the buffer and find the location of each item, so random access is possible */
	/* Calculate the total length at the same time */
	for (len = i = 0; i < count; i++)
	{
		result->pos[i] = len;
		len += 3 + result->buffer[len];
	}
	
	return (PyObject*)result;
}

PyObject* _glRenderMode (GLenum mode)
{
	GLint previous_mode, count;

	glGetIntegerv(GL_RENDER_MODE, &previous_mode);
	count = glRenderMode(mode);
	
	/* count == -1 means that there wasn't enough space in the buffer */
	/* Sould this be an exception? */
	if (count > -1) {
		switch (previous_mode)
		{
		case GL_SELECT:
			return PySelectBuffer_New(count);
		case GL_FEEDBACK:
			return PyFeedbackBuffer_New(count);
		}
		
		Py_INCREF(Py_None);
		return Py_None;
	} else {
		switch( previous_mode) {
			case GL_SELECT:
				PyErr_SetGLErrorMessage( GL_STACK_OVERFLOW, "glSelectBuffer too small to hold selection results" );
				break;
			case GL_FEEDBACK:
				PyErr_SetGLErrorMessage( GL_STACK_OVERFLOW, "glFeedbackBuffer too small to hold feedback results" );
				break;
			default:
				PyErr_SetGLErrorMessage( GL_NO_ERROR, "Unspecified error in glRenderMode" );
		}
		return NULL;
	}
}

 static char _doc_glRenderMode[] = "glRenderMode(mode) -> None | FeedbackBuffer | SelectBuffer"; 
 static char _doc_glRotated[] = "glRotated(angle, x, y, z) -> None"; 
 static char _doc_glRotatef[] = "glRotatef(angle, x, y, z) -> None"; 
 static char _doc_glScaled[] = "glScaled(x, y, z) -> None"; 
 static char _doc_glScalef[] = "glScalef(x, y, z) -> None"; 
 static char _doc_glScissor[] = "glScissor(x, y, width, height) -> None"; 

void _glSelectBuffer(GLsizei size)
{
	GLuint *buffer = (size > 0) ? PyMem_New(GLuint, size) : null_select_buffer;
#ifndef GL_VERSION_1_1
	PyGLcontext *context = GetGLcontext();
	context->selection_buffer = buffer;
#endif
	glSelectBuffer(size, buffer);
}

 static char _doc_glSelectBuffer[] = "glSelectBuffer(size) -> None"; 
 static char _doc_glShadeModel[] = "glShadeModel(mode) -> None"; 
 static char _doc_glStencilFunc[] = "glStencilFunc(func, ref, mask) -> None"; 
 static char _doc_glStencilMask[] = "glStencilMask(mask) -> None"; 
 static char _doc_glStencilOp[] = "glStencilOp(fail, zfail, zpass) -> None"; 
 static char _doc_glTexEnvf[] = "glTexEnvf(target, pname, param) -> None"; 
 static char _doc_glTexEnvfv[] = "glTexEnvfv(target, pname, v) -> None"; 
 static char _doc_glTexEnvi[] = "glTexEnvi(target, pname, param) -> None"; 
 static char _doc_glTexEnviv[] = "glTexEnviv(target, pname, v) -> None"; 
 static char _doc_glTexGend[] = "glTexGend(coord, pname, param) -> None"; 
 static char _doc_glTexGendv[] = "glTexGendv(coord, pname, v) -> None"; 
 static char _doc_glTexGenf[] = "glTexGenf(coord, pname, param) -> None"; 
 static char _doc_glTexGenfv[] = "glTexGenfv(coord, pname, v) -> None"; 
 static char _doc_glTexGeni[] = "glTexGeni(coord, pname, param) -> None"; 
 static char _doc_glTexGeniv[] = "glTexGeniv(coord, pname, v) -> None"; 
 static char _doc_glTexImage1D[] = "glTexImage1D(target, level, internalFormat, width, border, format, type, pixels) -> None"; 

void _glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	SetupPixelWrite(1);
	glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
}

 static char _doc_glTexImage1Dub[] = "glTexImage1Dub(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Db[] = "glTexImage1Db(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Dus[] = "glTexImage1Dus(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Ds[] = "glTexImage1Ds(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Dui[] = "glTexImage1Dui(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Di[] = "glTexImage1Di(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage1Df[] = "glTexImage1Df(target, level, internalFormat, border, format, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexImage2D[] = "glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) -> None"; 

void _glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
{
	SetupPixelWrite(2);
	glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
}

 static char _doc_glTexImage2Dub[] = "glTexImage2Dub(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Db[] = "glTexImage2Db(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Dus[] = "glTexImage2Dus(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Ds[] = "glTexImage2Ds(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Dui[] = "glTexImage2Dui(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Di[] = "glTexImage2Di(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexImage2Df[] = "glTexImage2Df(target, level, internalFormat, border, format, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexParameterf[] = "glTexParameterf(target, pname, param) -> None"; 
 static char _doc_glTexParameterfv[] = "glTexParameterfv(target, pname, v) -> None"; 
 static char _doc_glTexParameteri[] = "glTexParameteri(target, pname, param) -> None"; 
 static char _doc_glTexParameteriv[] = "glTexParameteriv(target, pname, v) -> None"; 
 static char _doc_glTexSubImage1D[] = "glTexSubImage1D(target, level, xoffset, width, format, type, pixels) -> None"; 

void _glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* pixels)
{
	SetupPixelWrite(1);
	glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
}

 static char _doc_glTexSubImage1Dub[] = "glTexSubImage1Dub(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Db[] = "glTexSubImage1Db(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Dus[] = "glTexSubImage1Dus(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Ds[] = "glTexSubImage1Ds(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Dui[] = "glTexSubImage1Dui(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Di[] = "glTexSubImage1Di(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage1Df[] = "glTexSubImage1Df(target, level, xoffset, format, type, pixels[] | pixels[][]) -> None"; 
 static char _doc_glTexSubImage2D[] = "glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) -> None"; 

void _glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
{
	SetupPixelWrite(2);
	glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

 static char _doc_glTexSubImage2Dub[] = "glTexSubImage2Dub(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Db[] = "glTexSubImage2Db(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Dus[] = "glTexSubImage2Dus(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Ds[] = "glTexSubImage2Ds(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Dui[] = "glTexSubImage2Dui(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Di[] = "glTexSubImage2Di(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTexSubImage2Df[] = "glTexSubImage2Df(target, level, xoffset, yoffset, format, type, pixels[][] | pixels[][][]) -> None"; 
 static char _doc_glTranslated[] = "glTranslated(x, y, z) -> None"; 
 static char _doc_glTranslatef[] = "glTranslatef(x, y, z) -> None"; 
 static char _doc_glViewport[] = "glViewport(x, y, width, height) -> None"; 
#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_glArrayElement(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glArrayElement",&obj0)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glArrayElement(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glBegin(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glBegin",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glBegin(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCallList(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glCallList",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glCallList(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCallLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLenum arg2 ;
    GLuint *arg3 = (GLuint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    
    {
        
    }
    {
        arg2 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glCallLists",&obj0)) goto fail;
    {
        arg3 = _PyObject_AsUnsignedIntArray(obj0, &temp_3, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_AsArray_Size(obj0); 
    }
    {
        glCallLists(arg1,arg2,(GLuint const *)arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3b(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte arg1 ;
    GLbyte arg2 ;
    GLbyte arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3b",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLbyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLbyte) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLbyte)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLbyte) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLbyte)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLbyte) PyString_AsString(obj2)[0];
        }
    }
    {
        glColor3b(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 = (GLbyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3bv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null CharArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3bv((GLbyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glColor3d(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glColor3f(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3i",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glColor3i(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3s",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        glColor3s(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3ub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte arg1 ;
    GLubyte arg2 ;
    GLubyte arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3ub",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLubyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLubyte) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLubyte)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLubyte) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLubyte)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLubyte) PyString_AsString(obj2)[0];
        }
    }
    {
        glColor3ub(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3ubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 = (GLubyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3ubv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedCharArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3ubv((GLubyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3ui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLuint arg2 ;
    GLuint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3ui",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLuint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLuint)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glColor3ui(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3uiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint *arg1 = (GLuint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3uiv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedIntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3uiv((GLuint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor3us(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort arg1 ;
    GLushort arg2 ;
    GLushort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glColor3us",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLushort)(SWIG_As_unsigned_SS_short(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLushort)(SWIG_As_unsigned_SS_short(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLushort)(SWIG_As_unsigned_SS_short(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glColor3us(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor3usv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort *arg1 = (GLushort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3usv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor3usv((GLushort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4b(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte arg1 ;
    GLbyte arg2 ;
    GLbyte arg3 ;
    GLbyte arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4b",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLbyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLbyte) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLbyte)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLbyte) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLbyte)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLbyte) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLbyte)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLbyte) PyString_AsString(obj3)[0];
        }
    }
    {
        glColor4b(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 = (GLbyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4bv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null CharArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4bv((GLbyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4d",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glColor4d(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4f",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glColor4f(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4i",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glColor4i(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    GLshort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4s",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLshort)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLshort) PyString_AsString(obj3)[0];
        }
    }
    {
        glColor4s(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4ub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte arg1 ;
    GLubyte arg2 ;
    GLubyte arg3 ;
    GLubyte arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4ub",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLubyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLubyte) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLubyte)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLubyte) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLubyte)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLubyte) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLubyte)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLubyte) PyString_AsString(obj3)[0];
        }
    }
    {
        glColor4ub(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4ubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 = (GLubyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4ubv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedCharArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4ubv((GLubyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4ui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLuint arg2 ;
    GLuint arg3 ;
    GLuint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4ui",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLuint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLuint)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLuint)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glColor4ui(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4uiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint *arg1 = (GLuint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4uiv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedIntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4uiv((GLuint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glColor4us(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort arg1 ;
    GLushort arg2 ;
    GLushort arg3 ;
    GLushort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColor4us",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLushort)(SWIG_As_unsigned_SS_short(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLushort)(SWIG_As_unsigned_SS_short(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLushort)(SWIG_As_unsigned_SS_short(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLushort)(SWIG_As_unsigned_SS_short(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glColor4us(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColor4usv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort *arg1 = (GLushort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4usv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null UnsignedShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glColor4usv((GLushort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEdgeFlag(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLboolean arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEdgeFlag",&obj0)) goto fail;
    {
        arg1= (PyObject_IsTrue(obj0)) ? GL_TRUE : GL_FALSE;
    }
    {
        glEdgeFlag(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEdgeFlagv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLboolean *arg1 = (GLboolean *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEdgeFlagv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, NULL); 
    }
    {
        glEdgeFlagv((GLboolean const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEvalCoord1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1d",&obj0)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glEvalCoord1d(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalCoord1dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glEvalCoord1dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEvalCoord1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1f",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glEvalCoord1f(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalCoord1fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glEvalCoord1fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEvalCoord2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glEvalCoord2d",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glEvalCoord2d(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalCoord2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord2dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glEvalCoord2dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEvalCoord2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glEvalCoord2f",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glEvalCoord2f(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalCoord2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord2fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glEvalCoord2fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glEvalPoint1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalPoint1",&obj0)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glEvalPoint1(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalPoint2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glEvalPoint2",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glEvalPoint2(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexd",&obj0)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glIndexd(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexdv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexdv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        glIndexdv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glIndexf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexf",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glIndexf(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexfv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        glIndexfv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glIndexi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexi",&obj0)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glIndexi(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexiv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        glIndexiv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glIndexs(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexs",&obj0)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        glIndexs(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexsv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexsv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        glIndexsv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glIndexub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexub",&obj0)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLubyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLubyte) PyString_AsString(obj0)[0];
        }
    }
    {
        glIndexub(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 = (GLubyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexubv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, NULL); 
    }
    {
        glIndexubv((GLubyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glMaterialf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMaterialf",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glMaterialf(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMaterialfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMaterialfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); 
    }
    {
        glMaterialfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glMateriali(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMateriali",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glMateriali(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMaterialiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 = (GLint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMaterialiv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, NULL); 
    }
    {
        glMaterialiv(arg1,arg2,(GLint const *)arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glNormal3b(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte arg1 ;
    GLbyte arg2 ;
    GLbyte arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glNormal3b",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLbyte)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLbyte) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLbyte)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLbyte) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLbyte)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLbyte) PyString_AsString(obj2)[0];
        }
    }
    {
        glNormal3b(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glNormal3bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 = (GLbyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3bv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null CharArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glNormal3bv((GLbyte const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glNormal3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glNormal3d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glNormal3d(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glNormal3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glNormal3dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glNormal3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glNormal3f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glNormal3f(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glNormal3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glNormal3fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glNormal3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glNormal3i",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glNormal3i(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glNormal3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glNormal3iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glNormal3s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glNormal3s",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        glNormal3s(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glNormal3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glNormal3sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1d",&obj0)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glTexCoord1d(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord1dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord1dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1f",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glTexCoord1f(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord1fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord1fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord1i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1i",&obj0)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glTexCoord1i(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord1iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord1iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord1s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1s",&obj0)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        glTexCoord1s(arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord1sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord1sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glTexCoord2d",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glTexCoord2d(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord2dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glTexCoord2f",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glTexCoord2f(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord2fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glTexCoord2i",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glTexCoord2i(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord2iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord2iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord2s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glTexCoord2s",&obj0,&obj1)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        glTexCoord2s(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord2sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord2sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexCoord3d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexCoord3d(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord3dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexCoord3f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexCoord3f(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord3fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexCoord3i",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexCoord3i(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord3iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord3s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexCoord3s",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        glTexCoord3s(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord3sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glTexCoord4d",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glTexCoord4d(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord4dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glTexCoord4f",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glTexCoord4f(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord4fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glTexCoord4i",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glTexCoord4i(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord4iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glTexCoord4s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    GLshort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glTexCoord4s",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLshort)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLshort) PyString_AsString(obj3)[0];
        }
    }
    {
        glTexCoord4s(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexCoord4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glTexCoord4sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glVertex2d",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glVertex2d(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex2dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glVertex2f",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glVertex2f(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex2fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glVertex2i",&obj0,&obj1)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        glVertex2i(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex2iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex2iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex2s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glVertex2s",&obj0,&obj1)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        glVertex2s(arg1,arg2);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex2sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex2sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glVertex3d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glVertex3d(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex3dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glVertex3f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glVertex3f(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex3fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glVertex3i",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glVertex3i(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex3iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex3s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glVertex3s",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        glVertex3s(arg1,arg2,arg3);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex3sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glVertex4d",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glVertex4d(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex4dv((GLdouble const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glVertex4f",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glVertex4f(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex4fv((GLfloat const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glVertex4i",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glVertex4i(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex4iv((GLint const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glVertex4s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    GLshort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glVertex4s",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLshort)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLshort) PyString_AsString(obj3)[0];
        }
    }
    {
        glVertex4s(arg1,arg2,arg3,arg4);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glVertex4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glVertex4sv((GLshort const *)arg1);
        
        if (PyErr_Occurred()) {
            return NULL;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap___has_extension(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 = (char *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:__has_extension",&obj0)) goto fail;
    if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
        SWIG_arg_fail(1);SWIG_fail;
    }
    {
        result = (int)has_extension((char const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glAccum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glAccum",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glAccum(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glAlphaFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLclampf arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glAlphaFunc",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLclampf)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glAlphaFunc(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glAreTexturesResident(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 = (GLuint *) 0 ;
    PyObject *result;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glAreTexturesResident",&obj0)) goto fail;
    {
        arg2 = _PyObject_AsUnsignedIntArray(obj0, &temp_2, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_AsArray_Size(obj0); 
    }
    {
        result = (PyObject *)_glAreTexturesResident(arg1,(GLuint const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glBindTexture(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLuint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glBindTexture",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLuint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glBindTexture(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glBitmap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    GLfloat arg5 ;
    GLfloat arg6 ;
    GLubyte *arg7 = (GLubyte *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:glBitmap",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLsizei)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if (arg1_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg1_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg1 = (GLsizei) PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLsizei)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if (arg2_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg2_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg2 = (GLsizei) PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLfloat)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLfloat)(SWIG_As_float(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsUnsignedCharArray(obj6, &temp_7, NULL); 
    }
    {
        glBitmap(arg1,arg2,arg3,arg4,arg5,arg6,(GLubyte const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glBlendFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glBlendFunc",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glBlendFunc(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClear(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbitfield arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glClear",&obj0)) goto fail;
    {
        arg1 = (GLbitfield)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glClear(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClearAccum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glClearAccum",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glClearAccum(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClearColor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampf arg1 ;
    GLclampf arg2 ;
    GLclampf arg3 ;
    GLclampf arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glClearColor",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLclampf)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLclampf)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLclampf)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLclampf)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glClearColor(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClearDepth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampd arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glClearDepth",&obj0)) goto fail;
    {
        arg1 = (GLclampd)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glClearDepth(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClearIndex(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glClearIndex",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glClearIndex(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClearStencil(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glClearStencil",&obj0)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glClearStencil(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glClipPlane(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble *arg2 = (GLdouble *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glClipPlane",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = _PyObject_AsDoubleArray(obj1, &temp_2, NULL); 
    }
    {
        glClipPlane(arg1,(GLdouble const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glColorMask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLboolean arg1 ;
    GLboolean arg2 ;
    GLboolean arg3 ;
    GLboolean arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glColorMask",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1= (PyObject_IsTrue(obj0)) ? GL_TRUE : GL_FALSE;
    }
    {
        arg2= (PyObject_IsTrue(obj1)) ? GL_TRUE : GL_FALSE;
    }
    {
        arg3= (PyObject_IsTrue(obj2)) ? GL_TRUE : GL_FALSE;
    }
    {
        arg4= (PyObject_IsTrue(obj3)) ? GL_TRUE : GL_FALSE;
    }
    {
        glColorMask(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glColorMaterial(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glColorMaterial",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glColorMaterial(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCopyPixels(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glCopyPixels",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        glCopyPixels(arg1,arg2,arg3,arg4,arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCopyTexImage1D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLsizei arg6 ;
    GLint arg7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:glCopyTexImage1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLint)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if ((arg4_temp_float <= INT_MIN-0.5) || (arg4_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg4 = PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLint)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if ((arg5_temp_float <= INT_MIN-0.5) || (arg5_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg5 = PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        if (PyInt_Check(obj5) || PyLong_Check(obj5)) {
            arg6= (GLsizei)(PyInt_AsLong( obj5 ));
        } else if (PyFloat_Check(obj5)) {
            double arg6_temp_float;
            arg6_temp_float = PyFloat_AsDouble(obj5);
            if (arg6_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg6_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg6 = (GLsizei) PyOpenGL_round( arg6_temp_float );
        }
    }
    {
        arg7 = (GLint)(SWIG_As_int(obj6)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        glCopyTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCopyTexImage2D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLsizei arg6 ;
    GLsizei arg7 ;
    GLint arg8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOO:glCopyTexImage2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLint)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if ((arg4_temp_float <= INT_MIN-0.5) || (arg4_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg4 = PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLint)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if ((arg5_temp_float <= INT_MIN-0.5) || (arg5_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg5 = PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        if (PyInt_Check(obj5) || PyLong_Check(obj5)) {
            arg6= (GLsizei)(PyInt_AsLong( obj5 ));
        } else if (PyFloat_Check(obj5)) {
            double arg6_temp_float;
            arg6_temp_float = PyFloat_AsDouble(obj5);
            if (arg6_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg6_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg6 = (GLsizei) PyOpenGL_round( arg6_temp_float );
        }
    }
    {
        if (PyInt_Check(obj6) || PyLong_Check(obj6)) {
            arg7= (GLsizei)(PyInt_AsLong( obj6 ));
        } else if (PyFloat_Check(obj6)) {
            double arg7_temp_float;
            arg7_temp_float = PyFloat_AsDouble(obj6);
            if (arg7_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg7_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg7 = (GLsizei) PyOpenGL_round( arg7_temp_float );
        }
    }
    {
        arg8 = (GLint)(SWIG_As_int(obj7)); 
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        glCopyTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCopyTexSubImage1D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLsizei arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glCopyTexSubImage1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLint)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if ((arg4_temp_float <= INT_MIN-0.5) || (arg4_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg4 = PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLint)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if ((arg5_temp_float <= INT_MIN-0.5) || (arg5_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg5 = PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        if (PyInt_Check(obj5) || PyLong_Check(obj5)) {
            arg6= (GLsizei)(PyInt_AsLong( obj5 ));
        } else if (PyFloat_Check(obj5)) {
            double arg6_temp_float;
            arg6_temp_float = PyFloat_AsDouble(obj5);
            if (arg6_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg6_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg6 = (GLsizei) PyOpenGL_round( arg6_temp_float );
        }
    }
    {
        glCopyTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCopyTexSubImage2D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLint arg6 ;
    GLsizei arg7 ;
    GLsizei arg8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOO:glCopyTexSubImage2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLint)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if ((arg5_temp_float <= INT_MIN-0.5) || (arg5_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg5 = PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        if (PyInt_Check(obj5) || PyLong_Check(obj5)) {
            arg6= (GLint)(PyInt_AsLong( obj5 ));
        } else if (PyFloat_Check(obj5)) {
            double arg6_temp_float;
            arg6_temp_float = PyFloat_AsDouble(obj5);
            if ((arg6_temp_float <= INT_MIN-0.5) || (arg6_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg6 = PyOpenGL_round( arg6_temp_float );
        }
    }
    {
        if (PyInt_Check(obj6) || PyLong_Check(obj6)) {
            arg7= (GLsizei)(PyInt_AsLong( obj6 ));
        } else if (PyFloat_Check(obj6)) {
            double arg7_temp_float;
            arg7_temp_float = PyFloat_AsDouble(obj6);
            if (arg7_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg7_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg7 = (GLsizei) PyOpenGL_round( arg7_temp_float );
        }
    }
    {
        if (PyInt_Check(obj7) || PyLong_Check(obj7)) {
            arg8= (GLsizei)(PyInt_AsLong( obj7 ));
        } else if (PyFloat_Check(obj7)) {
            double arg8_temp_float;
            arg8_temp_float = PyFloat_AsDouble(obj7);
            if (arg8_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg8_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg8 = (GLsizei) PyOpenGL_round( arg8_temp_float );
        }
    }
    {
        glCopyTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glCullFace(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glCullFace",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glCullFace(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDeleteLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLsizei arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glDeleteLists",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLsizei)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glDeleteLists(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDeleteTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 = (GLuint *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glDeleteTextures",&obj0)) goto fail;
    {
        arg2 = _PyObject_AsUnsignedIntArray(obj0, &temp_2, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_AsArray_Size(obj0); 
    }
    {
        glDeleteTextures(arg1,(GLuint const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glDepthFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glDepthFunc",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glDepthFunc(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDepthMask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLboolean arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glDepthMask",&obj0)) goto fail;
    {
        arg1= (PyObject_IsTrue(obj0)) ? GL_TRUE : GL_FALSE;
    }
    {
        glDepthMask(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDepthRange(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampd arg1 ;
    GLclampd arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glDepthRange",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLclampd)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLclampd)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glDepthRange(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDisable(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glDisable",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glDisable(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDisableClientState(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glDisableClientState",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glDisableClientState(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDrawBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glDrawBuffer",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glDrawBuffer(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDrawPixels(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    void *arg5 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glDrawPixels",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLsizei)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if (arg1_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg1_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg1 = (GLsizei) PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLsizei)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if (arg2_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg2_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg2 = (GLsizei) PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        int len;
        PyObject* str;
        if (obj4 == Py_None) 
        {
            arg5= NULL; 
        }
        else
        {
            str = PyObject_Str(obj4);
            PyString_AsStringAndSize(str, (char**)&arg5, &len);
            Py_DECREF(str);
        }
    }
    {
        glDrawPixels(arg1,arg2,arg3,arg4,(void const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glDrawPixelsub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLubyte *arg5 = (GLubyte *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsub",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsUnsignedCharArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLubyte const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelsb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLbyte *arg5 = (GLbyte *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsb",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsCharArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLbyte const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelsus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLushort *arg5 = (GLushort *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsus",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsUnsignedShortArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLushort const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelss(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLshort *arg5 = (GLshort *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelss",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsShortArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLshort const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelsui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLuint *arg5 = (GLuint *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsui",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsUnsignedIntArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLuint const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelsi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLint *arg5 = (GLint *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsi",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsIntArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLint const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glDrawPixelsf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLfloat *arg5 = (GLfloat *) 0 ;
    PyObject *temp_5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg4 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsf",&obj0,&obj1)) goto fail;
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = _PyObject_AsFloatArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        _glDrawPixels(arg1,arg2,arg3,arg4,(GLfloat const *)arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg5, temp_5); 
    }
    return NULL;
}


static PyObject *_wrap_glEnable(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEnable",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glEnable(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEnableClientState(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEnableClientState",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glEnableClientState(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEnd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glEnd")) goto fail;
    {
        glEnd();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEndList(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glEndList")) goto fail;
    {
        glEndList();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalMesh1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glEvalMesh1",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glEvalMesh1(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glEvalMesh2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glEvalMesh2",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        glEvalMesh2(arg1,arg2,arg3,arg4,arg5);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFeedbackBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFeedbackBuffer",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLsizei)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        _glFeedbackBuffer(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFinish(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glFinish")) goto fail;
    {
        glFinish();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFlush(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glFlush")) goto fail;
    {
        glFlush();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFogf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogf",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glFogf(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFogfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat *arg2 = (GLfloat *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = _PyObject_AsFloatArray(obj1, &temp_2, NULL); 
    }
    {
        if (!arg2) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 2 ); 		return NULL; 	
        } 
    }
    {
        glFogfv(arg1,(GLfloat const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glFogi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogi",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glFogi(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFogiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint *arg2 = (GLint *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogiv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = _PyObject_AsIntArray(obj1, &temp_2, NULL); 
    }
    {
        if (!arg2) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 2 ); 		return NULL; 	
        } 
    }
    {
        glFogiv(arg1,(GLint const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glFrontFace(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glFrontFace",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glFrontFace(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glFrustum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glFrustum",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLdouble)(SWIG_As_double(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLdouble)(SWIG_As_double(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        glFrustum(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGenLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGenLists",&obj0)) goto fail;
    {
        arg1 = (GLsizei)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (GLuint)glGenLists(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGenTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGenTextures",&obj0)) goto fail;
    {
        arg1 = (GLsizei)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGenTextures(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetBooleanv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLboolean *arg2 ;
    unsigned char temp_2[16] ;
    PyObject * obj0 = 0 ;
    
    {
        int i; 	arg2 = temp_2; 	for (i = 0; i < 16; i++) arg2[i] = 255; 
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glGetBooleanv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glGetBooleanv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 16 && arg2[n] != 255; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg2[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromUnsignedCharArray(2, dims, arg2, 0); 		break; 	default: 		resultobj = _PyTuple_FromUnsignedCharArray(n, arg2); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetClipPlane(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble *arg2 ;
    double temp_2[4] ;
    PyObject * obj0 = 0 ;
    
    {
        int i; 	arg2 = temp_2; 	for (i = 0; i < 4; i++) arg2[i] = -DBL_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glGetClipPlane",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glGetClipPlane(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg2[n] != -DBL_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg2[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromDoubleArray(2, dims, arg2, 0); 		break; 	default: 		resultobj = _PyTuple_FromDoubleArray(n, arg2); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetDoublev(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble *arg2 ;
    double temp_2[16] ;
    PyObject * obj0 = 0 ;
    
    {
        int i; 	arg2 = temp_2; 	for (i = 0; i < 16; i++) arg2[i] = -DBL_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glGetDoublev",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glGetDoublev(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 16 && arg2[n] != -DBL_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg2[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromDoubleArray(2, dims, arg2, 0); 		break; 	default: 		resultobj = _PyTuple_FromDoubleArray(n, arg2); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetFloatv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat *arg2 ;
    float temp_2[16] ;
    PyObject * obj0 = 0 ;
    
    {
        int i; 	arg2 = temp_2; 	for (i = 0; i < 16; i++) arg2[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glGetFloatv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glGetFloatv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 16 && arg2[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg2[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg2, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg2); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetIntegerv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint *arg2 ;
    int temp_2[16] ;
    PyObject * obj0 = 0 ;
    
    {
        int i; 	arg2 = temp_2; 	for (i = 0; i < 16; i++) arg2[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glGetIntegerv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glGetIntegerv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 16 && arg2[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg2[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg2, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg2); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetLightfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    float temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetLightfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetLightfv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetLightiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    int temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetLightiv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetLightiv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetMapdv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetMapdv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetMapdv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetMapfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetMapfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetMapdv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetMapiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetMapiv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetMapiv(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetMaterialfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    float temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetMaterialfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetMaterialfv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetMaterialiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    int temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetMaterialiv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetMaterialiv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetPixelMapfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGetPixelMapfv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetPixelMapfv(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetPixelMapuiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGetPixelMapuiv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetPixelMapuiv(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetPixelMapusv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGetPixelMapusv",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetPixelMapusv(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetPolygonStipple(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *result;
    
    if(!PyArg_ParseTuple(args,(char *)":glGetPolygonStipple")) goto fail;
    {
        result = (PyObject *)_glGetPolygonStipple();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetPolygonStippleub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *result;
    
    if(!PyArg_ParseTuple(args,(char *)":glGetPolygonStippleub")) goto fail;
    {
        result = (PyObject *)glGetPolygonStippleub();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetString(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLubyte *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glGetString",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (GLubyte *)glGetString(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        if (result) 
        {
            resultobj= PyString_FromString(result); 
        }
        else 
        {
            Py_INCREF(resultobj = Py_None);
        }
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexEnvfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    float temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexEnvfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexEnvfv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexEnviv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    int temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexEnviv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexEnviv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexGendv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLdouble *arg3 ;
    double temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -DBL_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexGendv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexGendv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -DBL_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromDoubleArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromDoubleArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexGenfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    float temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexGenfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexGenfv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexGeniv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    int temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexGeniv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexGeniv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImage(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glGetTexImage",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        result = (PyObject *)_glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImageub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImageub",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImageb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImageb",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImageus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImageus",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImages(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImages",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImageui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImageui",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImagei(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImagei",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImagef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImagef",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexImaged(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        arg4 = GL_DOUBLE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexImaged",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexLevelParameterfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLfloat *arg4 ;
    float temp_4[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        int i; 	arg4 = temp_4; 	for (i = 0; i < 4; i++) arg4[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexLevelParameterfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glGetTexLevelParameterfv(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg4[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg4[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg4, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg4); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexLevelParameteriv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLint *arg4 ;
    int temp_4[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    {
        int i; 	arg4 = temp_4; 	for (i = 0; i < 4; i++) arg4[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO:glGetTexLevelParameteriv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glGetTexLevelParameteriv(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg4[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg4[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg4, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg4); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexParameterfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    float temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexParameterfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexParameterfv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != -FLT_MAX; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyFloat_FromDouble(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromFloatArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromFloatArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glGetTexParameteriv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    int temp_3[4] ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        int i; 	arg3 = temp_3; 	for (i = 0; i < 4; i++) arg3[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glGetTexParameteriv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glGetTexParameteriv(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        int n, dims[2]; 	Py_XDECREF(resultobj); 	 	for (n = 0; n < 4 && arg3[n] != INT_MIN; n++); 	switch (n) 	{
            case 0: 		Py_INCREF(Py_None); 		resultobj = Py_None; 		break; 	case 1: 		resultobj = PyInt_FromLong(arg3[0]); 		break; 	case 16: 		dims[0] = 4; 		dims[1] = 4; 		resultobj = _PyObject_FromIntArray(2, dims, arg3, 0); 		break; 	default: 		resultobj = _PyTuple_FromIntArray(n, arg3); 	
        } 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glHint(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glHint",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glHint(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIndexMask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexMask",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glIndexMask(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glInitNames(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glInitNames")) goto fail;
    {
        glInitNames();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIsEnabled(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLboolean result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIsEnabled",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (GLboolean)glIsEnabled(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIsList(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLboolean result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIsList",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (GLboolean)glIsList(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glIsTexture(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLboolean result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIsTexture",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (GLboolean)glIsTexture(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLightModelf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModelf",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glLightModelf(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLightModelfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat *arg2 = (GLfloat *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModelfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = _PyObject_AsFloatArray(obj1, &temp_2, NULL); 
    }
    {
        if (!arg2) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 2 ); 		return NULL; 	
        } 
    }
    {
        glLightModelfv(arg1,(GLfloat const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glLightModeli(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModeli",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glLightModeli(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLightModeliv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint *arg2 = (GLint *) 0 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModeliv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = _PyObject_AsIntArray(obj1, &temp_2, NULL); 
    }
    {
        if (!arg2) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 2 ); 		return NULL; 	
        } 
    }
    {
        glLightModeliv(arg1,(GLint const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glLightf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLightf",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glLightf(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLightfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLightfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glLightfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glLighti(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLighti",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glLighti(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLightiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 = (GLint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLightiv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glLightiv(arg1,arg2,(GLint const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glLineStipple(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLushort arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLineStipple",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLushort)(SWIG_As_unsigned_SS_short(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glLineStipple(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLineWidth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glLineWidth",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glLineWidth(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glListBase(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glListBase",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glListBase(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLoadIdentity(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glLoadIdentity")) goto fail;
    {
        glLoadIdentity();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLoadMatrixd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glLoadMatrixd",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glLoadMatrixd((GLdouble const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glLoadMatrixf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glLoadMatrixf",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glLoadMatrixf((GLfloat const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glLoadName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glLoadName",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glLoadName(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glLogicOp(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glLogicOp",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glLogicOp(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMap1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLdouble *arg6 = (GLdouble *) 0 ;
    PyObject *temp_6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    {
        
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glMap1d",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = _PyObject_AsDoubleArray(obj3, &temp_6, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj3, 1); 
    }
    {
        arg5 = (GLint)_PyObject_Dimension(obj3, 0); 
    }
    {
        glMap1d(arg1,arg2,arg3,arg4,arg5,(GLdouble const *)arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg6, temp_6); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg6, temp_6); 
    }
    return NULL;
}


static PyObject *_wrap_glMap1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLfloat *arg6 = (GLfloat *) 0 ;
    PyObject *temp_6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    {
        
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glMap1f",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = _PyObject_AsFloatArray(obj3, &temp_6, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj3, 1); 
    }
    {
        arg5 = (GLint)_PyObject_Dimension(obj3, 0); 
    }
    {
        glMap1f(arg1,arg2,arg3,arg4,arg5,(GLfloat const *)arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg6, temp_6); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg6, temp_6); 
    }
    return NULL;
}


static PyObject *_wrap_glMap2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLint arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    GLint arg7 ;
    GLint arg8 ;
    GLdouble *arg9 = (GLdouble *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glMap2d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLdouble)(SWIG_As_double(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsDoubleArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj5, 0); 
    }
    {
        arg7 = (GLint)_PyObject_Dimension(obj5, 2); 
    }
    {
        arg8 = (GLint)_PyObject_Dimension(obj5, 1); 
    }
    {
        _glMap2d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLdouble const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glMap2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLint arg4 ;
    GLfloat arg5 ;
    GLfloat arg6 ;
    GLint arg7 ;
    GLint arg8 ;
    GLfloat *arg9 = (GLfloat *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glMap2f",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLfloat)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsFloatArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj5, 0); 
    }
    {
        arg7 = (GLint)_PyObject_Dimension(obj5, 2); 
    }
    {
        arg8 = (GLint)_PyObject_Dimension(obj5, 1); 
    }
    {
        _glMap2f(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLfloat const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glMapGrid1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMapGrid1d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glMapGrid1d(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMapGrid1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMapGrid1f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glMapGrid1f(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMapGrid2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLint arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glMapGrid2d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLdouble)(SWIG_As_double(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLdouble)(SWIG_As_double(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        glMapGrid2d(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMapGrid2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLint arg4 ;
    GLfloat arg5 ;
    GLfloat arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glMapGrid2f",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLfloat)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLfloat)(SWIG_As_float(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        glMapGrid2f(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMatrixMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glMatrixMode",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glMatrixMode(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glMultMatrixd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glMultMatrixd",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glMultMatrixd((GLdouble const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glMultMatrixf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glMultMatrixf",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glMultMatrixf((GLfloat const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glNewList(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glNewList",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glNewList(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glOrtho(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glOrtho",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (GLdouble)(SWIG_As_double(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLdouble)(SWIG_As_double(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        glOrtho(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPassThrough(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPassThrough",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glPassThrough(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPixelMapfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapfv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj1, &temp_3, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glPixelMapfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glPixelMapuiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLuint *arg3 = (GLuint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapuiv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsUnsignedIntArray(obj1, &temp_3, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glPixelMapuiv(arg1,arg2,(GLuint const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glPixelMapusv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLushort *arg3 = (GLushort *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapusv",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsUnsignedShortArray(obj1, &temp_3, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glPixelMapusv(arg1,arg2,(GLushort const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glPixelStoref(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelStoref",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPixelStoref(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPixelStorei(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelStorei",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPixelStorei(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPixelTransferf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelTransferf",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPixelTransferf(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPixelTransferi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelTransferi",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPixelTransferi(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPixelZoom(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelZoom",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPixelZoom(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPointSize(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPointSize",&obj0)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glPointSize(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPolygonMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glPolygonMode",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glPolygonMode(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPolygonStipple(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPolygonStipple",&obj0)) goto fail;
    {
        int len;
        PyObject* str;
        if (obj0 == Py_None) 
        {
            arg1= NULL; 
        }
        else
        {
            str = PyObject_Str(obj0);
            PyString_AsStringAndSize(str, (char**)&arg1, &len);
            Py_DECREF(str);
        }
    }
    {
        glPolygonStipple((void const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPolygonStippleub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 = (GLubyte *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPolygonStippleub",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, NULL); 
    }
    {
        glPolygonStippleub((GLubyte const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glPopAttrib(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glPopAttrib")) goto fail;
    {
        glPopAttrib();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPopClientAttrib(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glPopClientAttrib")) goto fail;
    {
        _glPopClientAttrib();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPopMatrix(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glPopMatrix")) goto fail;
    {
        glPopMatrix();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPopName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glPopName")) goto fail;
    {
        glPopName();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPrioritizeTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 = (GLuint *) 0 ;
    GLclampf *arg3 = (GLclampf *) 0 ;
    PyObject *temp_2 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPrioritizeTextures",&obj0,&obj1)) goto fail;
    {
        arg2 = _PyObject_AsUnsignedIntArray(obj0, &temp_2, NULL); 
    }
    {
        arg3 = _PyObject_AsFloatArray(obj1, &temp_3, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_AsArray_Size(obj0); 
    }
    {
        glPrioritizeTextures(arg1,(GLuint const *)arg2,(GLclampf const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glPushAttrib(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbitfield arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPushAttrib",&obj0)) goto fail;
    {
        arg1 = (GLbitfield)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glPushAttrib(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPushClientAttrib(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbitfield arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPushClientAttrib",&obj0)) goto fail;
    {
        arg1 = (GLbitfield)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        _glPushClientAttrib(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPushMatrix(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glPushMatrix")) goto fail;
    {
        glPushMatrix();
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glPushName(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPushName",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glPushName(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRasterPos2d",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glRasterPos2d(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos2dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos2dv((GLdouble const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRasterPos2f",&obj0,&obj1)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        glRasterPos2f(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos2fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos2fv((GLfloat const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRasterPos2i",&obj0,&obj1)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        glRasterPos2i(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos2iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos2iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos2iv((GLint const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos2s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRasterPos2s",&obj0,&obj1)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        glRasterPos2s(arg1,arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos2sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos2sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos2sv((GLshort const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glRasterPos3d",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glRasterPos3d(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos3dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos3dv((GLdouble const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glRasterPos3f",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glRasterPos3f(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos3fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos3fv((GLfloat const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glRasterPos3i",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glRasterPos3i(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos3iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos3iv((GLint const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos3s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glRasterPos3s",&obj0,&obj1,&obj2)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        glRasterPos3s(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos3sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos3sv((GLshort const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRasterPos4d",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRasterPos4d(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos4dv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos4dv((GLdouble const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRasterPos4f",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRasterPos4f(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos4fv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos4fv((GLfloat const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRasterPos4i",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRasterPos4i(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos4iv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos4iv((GLint const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glRasterPos4s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    GLshort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRasterPos4s",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLshort)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLshort) PyString_AsString(obj3)[0];
        }
    }
    {
        glRasterPos4s(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRasterPos4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRasterPos4sv",&obj0)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        if (!arg1) {
            PyErr_Format( PyExc_TypeError, "Expect non-null ShortArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 1 ); 		return NULL; 	
        } 
    }
    {
        glRasterPos4sv((GLshort const *)arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    return NULL;
}


static PyObject *_wrap_glReadBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glReadBuffer",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glReadBuffer(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixels(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glReadPixels",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        result = (PyObject *)_glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsub",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsb",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsus",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelss(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelss",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsui",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsi",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsf",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glReadPixelsd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        arg6 = GL_DOUBLE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glReadPixelsd",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRectd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRectd",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRectd(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRectdv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 = (GLdouble *) 0 ;
    GLdouble *arg2 = (GLdouble *) 0 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectdv",&obj0,&obj1)) goto fail;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, NULL); 
    }
    {
        arg2 = _PyObject_AsDoubleArray(obj1, &temp_2, NULL); 
    }
    {
        glRectdv((GLdouble const *)arg1,(GLdouble const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glRectf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRectf",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRectf(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRectfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 = (GLfloat *) 0 ;
    GLfloat *arg2 = (GLfloat *) 0 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectfv",&obj0,&obj1)) goto fail;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, NULL); 
    }
    {
        arg2 = _PyObject_AsFloatArray(obj1, &temp_2, NULL); 
    }
    {
        glRectfv((GLfloat const *)arg1,(GLfloat const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glRecti(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRecti",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLint)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRecti(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRectiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 = (GLint *) 0 ;
    GLint *arg2 = (GLint *) 0 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectiv",&obj0,&obj1)) goto fail;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, NULL); 
    }
    {
        arg2 = _PyObject_AsIntArray(obj1, &temp_2, NULL); 
    }
    {
        glRectiv((GLint const *)arg1,(GLint const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glRects(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    GLshort arg2 ;
    GLshort arg3 ;
    GLshort arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRects",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0))
        {
            arg1= (GLshort)(PyInt_AsLong( obj0 ));
        }
        else if (PyString_Check (obj0))
        {
            /* what is a GLshort's size? */
            arg1= (GLshort) PyString_AsString(obj0)[0];
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1))
        {
            arg2= (GLshort)(PyInt_AsLong( obj1 ));
        }
        else if (PyString_Check (obj1))
        {
            /* what is a GLshort's size? */
            arg2= (GLshort) PyString_AsString(obj1)[0];
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2))
        {
            arg3= (GLshort)(PyInt_AsLong( obj2 ));
        }
        else if (PyString_Check (obj2))
        {
            /* what is a GLshort's size? */
            arg3= (GLshort) PyString_AsString(obj2)[0];
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3))
        {
            arg4= (GLshort)(PyInt_AsLong( obj3 ));
        }
        else if (PyString_Check (obj3))
        {
            /* what is a GLshort's size? */
            arg4= (GLshort) PyString_AsString(obj3)[0];
        }
    }
    {
        glRects(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRectsv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 = (GLshort *) 0 ;
    GLshort *arg2 = (GLshort *) 0 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectsv",&obj0,&obj1)) goto fail;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, NULL); 
    }
    {
        arg2 = _PyObject_AsShortArray(obj1, &temp_2, NULL); 
    }
    {
        glRectsv((GLshort const *)arg1,(GLshort const *)arg2);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg1, temp_1); 
    }
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return NULL;
}


static PyObject *_wrap_glRenderMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glRenderMode",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        result = (PyObject *)_glRenderMode(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    {
        resultobj= result;
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRotated(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRotated",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLdouble)(SWIG_As_double(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRotated(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glRotatef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glRotatef",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLfloat)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        glRotatef(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glScaled(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glScaled",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glScaled(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glScalef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glScalef",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glScalef(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glScissor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glScissor",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        glScissor(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glSelectBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glSelectBuffer",&obj0)) goto fail;
    {
        arg1 = (GLsizei)(SWIG_As_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        _glSelectBuffer(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glShadeModel(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glShadeModel",&obj0)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glShadeModel(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glStencilFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLuint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glStencilFunc",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLuint)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glStencilFunc(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glStencilMask(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glStencilMask",&obj0)) goto fail;
    {
        arg1 = (GLuint)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        glStencilMask(arg1);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glStencilOp(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLenum arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glStencilOp",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLenum)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glStencilOp(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexEnvf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnvf",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexEnvf(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexEnvfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnvfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexEnvfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexEnvi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnvi",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexEnvi(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexEnviv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 = (GLint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnviv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexEnviv(arg1,arg2,(GLint const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexGend(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGend",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexGend(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexGendv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLdouble *arg3 = (GLdouble *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGendv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsDoubleArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null DoubleArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexGendv(arg1,arg2,(GLdouble const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexGenf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGenf",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexGenf(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexGenfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGenfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexGenfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexGeni(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGeni",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexGeni(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexGeniv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 = (GLint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGeniv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexGeniv(arg1,arg2,(GLint const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    void *arg8 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOO:glTexImage1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj6)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        int len;
        PyObject* str;
        if (obj7 == Py_None) 
        {
            arg8= NULL; 
        }
        else
        {
            str = PyObject_Str(obj7);
            PyString_AsStringAndSize(str, (char**)&arg8, &len);
            Py_DECREF(str);
        }
    }
    {
        glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(void const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexImage1Dub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLubyte *arg8 = (GLubyte *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Dub",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsUnsignedCharArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLubyte const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Db(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLbyte *arg8 = (GLbyte *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Db",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsCharArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLbyte const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Dus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLushort *arg8 = (GLushort *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Dus",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsUnsignedShortArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLushort const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Ds(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLshort *arg8 = (GLshort *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Ds",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsShortArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLshort const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Dui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLuint *arg8 = (GLuint *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Dui",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsUnsignedIntArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLuint const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Di(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLint *arg8 = (GLint *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Di",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsIntArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLint const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage1Df(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLint arg5 ;
    GLenum arg6 ;
    GLenum arg7 ;
    GLfloat *arg8 = (GLfloat *) 0 ;
    PyObject *temp_8 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        arg7 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage1Df",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg8 = _PyObject_AsFloatArray(obj5, &temp_8, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj4, 0); 
    }
    {
        _glTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(GLfloat const *)arg8);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg8, temp_8); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    void *arg9 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:glTexImage2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLsizei)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if (arg5_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg5_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg5 = (GLsizei) PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj6)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg8 = (GLenum)(SWIG_As_unsigned_SS_int(obj7)); 
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        int len;
        PyObject* str;
        if (obj8 == Py_None) 
        {
            arg9= NULL; 
        }
        else
        {
            str = PyObject_Str(obj8);
            PyString_AsStringAndSize(str, (char**)&arg9, &len);
            Py_DECREF(str);
        }
    }
    {
        glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(void const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexImage2Dub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLubyte *arg9 = (GLubyte *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Dub",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedCharArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLubyte const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Db(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLbyte *arg9 = (GLbyte *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Db",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsCharArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLbyte const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Dus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLushort *arg9 = (GLushort *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Dus",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedShortArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLushort const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Ds(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLshort *arg9 = (GLshort *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Ds",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsShortArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLshort const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Dui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLuint *arg9 = (GLuint *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Dui",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedIntArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLuint const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Di(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLint *arg9 = (GLint *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Di",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsIntArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLint const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexImage2Df(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLsizei arg5 ;
    GLint arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLfloat *arg9 = (GLfloat *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexImage2Df",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg6 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsFloatArray(obj5, &temp_9, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLfloat const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexParameterf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameterf",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexParameterf(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexParameterfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 = (GLfloat *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameterfv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null FloatArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexParameterfv(arg1,arg2,(GLfloat const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexParameteri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameteri",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTexParameteri(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexParameteriv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 = (GLint *) 0 ;
    PyObject *temp_3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameteriv",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLenum)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, NULL); 
    }
    {
        if (!arg3) {
            PyErr_Format( PyExc_TypeError, "Expect non-null IntArray pointer (i.e. an array/list/tuple) for argument %d, got null pointer", 3 ); 		return NULL; 	
        } 
    }
    {
        glTexParameteriv(arg1,arg2,(GLint const *)arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg3, temp_3); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    void *arg7 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOO:glTexSubImage1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (GLenum)(SWIG_As_unsigned_SS_int(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        int len;
        PyObject* str;
        if (obj6 == Py_None) 
        {
            arg7= NULL; 
        }
        else
        {
            str = PyObject_Str(obj6);
            PyString_AsStringAndSize(str, (char**)&arg7, &len);
            Py_DECREF(str);
        }
    }
    {
        glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(void const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Dub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLubyte *arg7 = (GLubyte *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Dub",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsUnsignedCharArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLubyte const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Db(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLbyte *arg7 = (GLbyte *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Db",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsCharArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLbyte const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Dus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLushort *arg7 = (GLushort *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Dus",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsUnsignedShortArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLushort const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Ds(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLshort *arg7 = (GLshort *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Ds",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsShortArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLshort const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Dui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLuint *arg7 = (GLuint *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Dui",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsUnsignedIntArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLuint const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Di(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLint *arg7 = (GLint *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Di",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsIntArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLint const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage1Df(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLfloat *arg7 = (GLfloat *) 0 ;
    PyObject *temp_7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    {
        
    }
    {
        arg6 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:glTexSubImage1Df",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg5 = (GLenum)(SWIG_As_unsigned_SS_int(obj3)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg7 = _PyObject_AsFloatArray(obj4, &temp_7, NULL); 
    }
    {
        arg4 = (GLsizei)_PyObject_Dimension(obj3, 0); 
    }
    {
        _glTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6,(GLfloat const *)arg7);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg7, temp_7); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    void *arg9 = (void *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:glTexSubImage2D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        if (PyInt_Check(obj4) || PyLong_Check(obj4)) {
            arg5= (GLsizei)(PyInt_AsLong( obj4 ));
        } else if (PyFloat_Check(obj4)) {
            double arg5_temp_float;
            arg5_temp_float = PyFloat_AsDouble(obj4);
            if (arg5_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg5_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg5 = (GLsizei) PyOpenGL_round( arg5_temp_float );
        }
    }
    {
        if (PyInt_Check(obj5) || PyLong_Check(obj5)) {
            arg6= (GLsizei)(PyInt_AsLong( obj5 ));
        } else if (PyFloat_Check(obj5)) {
            double arg6_temp_float;
            arg6_temp_float = PyFloat_AsDouble(obj5);
            if (arg6_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg6_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg6 = (GLsizei) PyOpenGL_round( arg6_temp_float );
        }
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj6)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg8 = (GLenum)(SWIG_As_unsigned_SS_int(obj7)); 
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        int len;
        PyObject* str;
        if (obj8 == Py_None) 
        {
            arg9= NULL; 
        }
        else
        {
            str = PyObject_Str(obj8);
            PyString_AsStringAndSize(str, (char**)&arg9, &len);
            Py_DECREF(str);
        }
    }
    {
        glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(void const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Dub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLubyte *arg9 = (GLubyte *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Dub",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedCharArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLubyte const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Db(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLbyte *arg9 = (GLbyte *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Db",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsCharArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLbyte const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Dus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLushort *arg9 = (GLushort *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Dus",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedShortArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLushort const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Ds(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLshort *arg9 = (GLshort *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Ds",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsShortArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLshort const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Dui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLuint *arg9 = (GLuint *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Dui",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsUnsignedIntArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLuint const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Di(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLint *arg9 = (GLint *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Di",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsIntArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLint const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTexSubImage2Df(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLsizei arg5 ;
    GLsizei arg6 ;
    GLenum arg7 ;
    GLenum arg8 ;
    GLfloat *arg9 = (GLfloat *) 0 ;
    PyObject *temp_9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    {
        
    }
    {
        
    }
    {
        arg8 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:glTexSubImage2Df",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    {
        arg1 = (GLenum)(SWIG_As_unsigned_SS_int(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLint)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLint)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (GLint)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg7 = (GLenum)(SWIG_As_unsigned_SS_int(obj4)); 
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        arg9 = _PyObject_AsFloatArray(obj5, &temp_9, NULL); 
    }
    {
        arg5 = (GLsizei)_PyObject_Dimension(obj5, 1); 
    }
    {
        arg6 = (GLsizei)_PyObject_Dimension(obj5, 0); 
    }
    {
        _glTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(GLfloat const *)arg9);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return resultobj;
    fail:
    {
        _PyObject_AsArray_Cleanup(arg9, temp_9); 
    }
    return NULL;
}


static PyObject *_wrap_glTranslated(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTranslated",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLdouble)(SWIG_As_double(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLdouble)(SWIG_As_double(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLdouble)(SWIG_As_double(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTranslated(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glTranslatef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTranslatef",&obj0,&obj1,&obj2)) goto fail;
    {
        arg1 = (GLfloat)(SWIG_As_float(obj0)); 
        if (SWIG_arg_fail(1)) SWIG_fail;
    }
    {
        arg2 = (GLfloat)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (GLfloat)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        glTranslatef(arg1,arg2,arg3);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_glViewport(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:glViewport",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        if (PyInt_Check(obj0) || PyLong_Check(obj0)) {
            arg1= (GLint)(PyInt_AsLong( obj0 ));
        } else if (PyFloat_Check(obj0)) {
            double arg1_temp_float;
            arg1_temp_float = PyFloat_AsDouble(obj0);
            if ((arg1_temp_float <= INT_MIN-0.5) || (arg1_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg1 = PyOpenGL_round( arg1_temp_float );
        }
    }
    {
        if (PyInt_Check(obj1) || PyLong_Check(obj1)) {
            arg2= (GLint)(PyInt_AsLong( obj1 ));
        } else if (PyFloat_Check(obj1)) {
            double arg2_temp_float;
            arg2_temp_float = PyFloat_AsDouble(obj1);
            if ((arg2_temp_float <= INT_MIN-0.5) || (arg2_temp_float >= INT_MAX+0.5)) {
                PyErr_SetString(PyExc_ValueError, "GLint value too large to convert");
                return NULL;
            }
            arg2 = PyOpenGL_round( arg2_temp_float );
        }
    }
    {
        if (PyInt_Check(obj2) || PyLong_Check(obj2)) {
            arg3= (GLsizei)(PyInt_AsLong( obj2 ));
        } else if (PyFloat_Check(obj2)) {
            double arg3_temp_float;
            arg3_temp_float = PyFloat_AsDouble(obj2);
            if (arg3_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg3_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg3 = (GLsizei) PyOpenGL_round( arg3_temp_float );
        }
    }
    {
        if (PyInt_Check(obj3) || PyLong_Check(obj3)) {
            arg4= (GLsizei)(PyInt_AsLong( obj3 ));
        } else if (PyFloat_Check(obj3)) {
            double arg4_temp_float;
            arg4_temp_float = PyFloat_AsDouble(obj3);
            if (arg4_temp_float >= (INT_MAX-0.5)) {
                PyErr_SetString(PyExc_ValueError, "Value too large to be converted to a size measurement");
                return NULL;
            } else if (arg4_temp_float <= -0.5) {
                PyErr_SetString(PyExc_ValueError, "Value less than 0, cannot be converted to a size measurement");
                return NULL;
            }
            arg4 = (GLsizei) PyOpenGL_round( arg4_temp_float );
        }
    }
    {
        glViewport(arg1,arg2,arg3,arg4);
        
        if (GLErrOccurred()) {
            return NULL; 
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"glArrayElement", _wrap_glArrayElement, METH_VARARGS, NULL},
	 { (char *)"glBegin", _wrap_glBegin, METH_VARARGS, NULL},
	 { (char *)"glCallList", _wrap_glCallList, METH_VARARGS, NULL},
	 { (char *)"glCallLists", _wrap_glCallLists, METH_VARARGS, NULL},
	 { (char *)"glColor3b", _wrap_glColor3b, METH_VARARGS, NULL},
	 { (char *)"glColor3bv", _wrap_glColor3bv, METH_VARARGS, NULL},
	 { (char *)"glColor3d", _wrap_glColor3d, METH_VARARGS, NULL},
	 { (char *)"glColor3dv", _wrap_glColor3dv, METH_VARARGS, NULL},
	 { (char *)"glColor3f", _wrap_glColor3f, METH_VARARGS, NULL},
	 { (char *)"glColor3fv", _wrap_glColor3fv, METH_VARARGS, NULL},
	 { (char *)"glColor3i", _wrap_glColor3i, METH_VARARGS, NULL},
	 { (char *)"glColor3iv", _wrap_glColor3iv, METH_VARARGS, NULL},
	 { (char *)"glColor3s", _wrap_glColor3s, METH_VARARGS, NULL},
	 { (char *)"glColor3sv", _wrap_glColor3sv, METH_VARARGS, NULL},
	 { (char *)"glColor3ub", _wrap_glColor3ub, METH_VARARGS, NULL},
	 { (char *)"glColor3ubv", _wrap_glColor3ubv, METH_VARARGS, NULL},
	 { (char *)"glColor3ui", _wrap_glColor3ui, METH_VARARGS, NULL},
	 { (char *)"glColor3uiv", _wrap_glColor3uiv, METH_VARARGS, NULL},
	 { (char *)"glColor3us", _wrap_glColor3us, METH_VARARGS, NULL},
	 { (char *)"glColor3usv", _wrap_glColor3usv, METH_VARARGS, NULL},
	 { (char *)"glColor4b", _wrap_glColor4b, METH_VARARGS, NULL},
	 { (char *)"glColor4bv", _wrap_glColor4bv, METH_VARARGS, NULL},
	 { (char *)"glColor4d", _wrap_glColor4d, METH_VARARGS, NULL},
	 { (char *)"glColor4dv", _wrap_glColor4dv, METH_VARARGS, NULL},
	 { (char *)"glColor4f", _wrap_glColor4f, METH_VARARGS, NULL},
	 { (char *)"glColor4fv", _wrap_glColor4fv, METH_VARARGS, NULL},
	 { (char *)"glColor4i", _wrap_glColor4i, METH_VARARGS, NULL},
	 { (char *)"glColor4iv", _wrap_glColor4iv, METH_VARARGS, NULL},
	 { (char *)"glColor4s", _wrap_glColor4s, METH_VARARGS, NULL},
	 { (char *)"glColor4sv", _wrap_glColor4sv, METH_VARARGS, NULL},
	 { (char *)"glColor4ub", _wrap_glColor4ub, METH_VARARGS, NULL},
	 { (char *)"glColor4ubv", _wrap_glColor4ubv, METH_VARARGS, NULL},
	 { (char *)"glColor4ui", _wrap_glColor4ui, METH_VARARGS, NULL},
	 { (char *)"glColor4uiv", _wrap_glColor4uiv, METH_VARARGS, NULL},
	 { (char *)"glColor4us", _wrap_glColor4us, METH_VARARGS, NULL},
	 { (char *)"glColor4usv", _wrap_glColor4usv, METH_VARARGS, NULL},
	 { (char *)"glEdgeFlag", _wrap_glEdgeFlag, METH_VARARGS, NULL},
	 { (char *)"glEdgeFlagv", _wrap_glEdgeFlagv, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord1d", _wrap_glEvalCoord1d, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord1dv", _wrap_glEvalCoord1dv, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord1f", _wrap_glEvalCoord1f, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord1fv", _wrap_glEvalCoord1fv, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord2d", _wrap_glEvalCoord2d, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord2dv", _wrap_glEvalCoord2dv, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord2f", _wrap_glEvalCoord2f, METH_VARARGS, NULL},
	 { (char *)"glEvalCoord2fv", _wrap_glEvalCoord2fv, METH_VARARGS, NULL},
	 { (char *)"glEvalPoint1", _wrap_glEvalPoint1, METH_VARARGS, NULL},
	 { (char *)"glEvalPoint2", _wrap_glEvalPoint2, METH_VARARGS, NULL},
	 { (char *)"glIndexd", _wrap_glIndexd, METH_VARARGS, NULL},
	 { (char *)"glIndexdv", _wrap_glIndexdv, METH_VARARGS, NULL},
	 { (char *)"glIndexf", _wrap_glIndexf, METH_VARARGS, NULL},
	 { (char *)"glIndexfv", _wrap_glIndexfv, METH_VARARGS, NULL},
	 { (char *)"glIndexi", _wrap_glIndexi, METH_VARARGS, NULL},
	 { (char *)"glIndexiv", _wrap_glIndexiv, METH_VARARGS, NULL},
	 { (char *)"glIndexs", _wrap_glIndexs, METH_VARARGS, NULL},
	 { (char *)"glIndexsv", _wrap_glIndexsv, METH_VARARGS, NULL},
	 { (char *)"glIndexub", _wrap_glIndexub, METH_VARARGS, NULL},
	 { (char *)"glIndexubv", _wrap_glIndexubv, METH_VARARGS, NULL},
	 { (char *)"glMaterialf", _wrap_glMaterialf, METH_VARARGS, NULL},
	 { (char *)"glMaterialfv", _wrap_glMaterialfv, METH_VARARGS, NULL},
	 { (char *)"glMateriali", _wrap_glMateriali, METH_VARARGS, NULL},
	 { (char *)"glMaterialiv", _wrap_glMaterialiv, METH_VARARGS, NULL},
	 { (char *)"glNormal3b", _wrap_glNormal3b, METH_VARARGS, NULL},
	 { (char *)"glNormal3bv", _wrap_glNormal3bv, METH_VARARGS, NULL},
	 { (char *)"glNormal3d", _wrap_glNormal3d, METH_VARARGS, NULL},
	 { (char *)"glNormal3dv", _wrap_glNormal3dv, METH_VARARGS, NULL},
	 { (char *)"glNormal3f", _wrap_glNormal3f, METH_VARARGS, NULL},
	 { (char *)"glNormal3fv", _wrap_glNormal3fv, METH_VARARGS, NULL},
	 { (char *)"glNormal3i", _wrap_glNormal3i, METH_VARARGS, NULL},
	 { (char *)"glNormal3iv", _wrap_glNormal3iv, METH_VARARGS, NULL},
	 { (char *)"glNormal3s", _wrap_glNormal3s, METH_VARARGS, NULL},
	 { (char *)"glNormal3sv", _wrap_glNormal3sv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1d", _wrap_glTexCoord1d, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1dv", _wrap_glTexCoord1dv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1f", _wrap_glTexCoord1f, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1fv", _wrap_glTexCoord1fv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1i", _wrap_glTexCoord1i, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1iv", _wrap_glTexCoord1iv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1s", _wrap_glTexCoord1s, METH_VARARGS, NULL},
	 { (char *)"glTexCoord1sv", _wrap_glTexCoord1sv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2d", _wrap_glTexCoord2d, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2dv", _wrap_glTexCoord2dv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2f", _wrap_glTexCoord2f, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2fv", _wrap_glTexCoord2fv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2i", _wrap_glTexCoord2i, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2iv", _wrap_glTexCoord2iv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2s", _wrap_glTexCoord2s, METH_VARARGS, NULL},
	 { (char *)"glTexCoord2sv", _wrap_glTexCoord2sv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3d", _wrap_glTexCoord3d, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3dv", _wrap_glTexCoord3dv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3f", _wrap_glTexCoord3f, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3fv", _wrap_glTexCoord3fv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3i", _wrap_glTexCoord3i, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3iv", _wrap_glTexCoord3iv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3s", _wrap_glTexCoord3s, METH_VARARGS, NULL},
	 { (char *)"glTexCoord3sv", _wrap_glTexCoord3sv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4d", _wrap_glTexCoord4d, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4dv", _wrap_glTexCoord4dv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4f", _wrap_glTexCoord4f, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4fv", _wrap_glTexCoord4fv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4i", _wrap_glTexCoord4i, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4iv", _wrap_glTexCoord4iv, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4s", _wrap_glTexCoord4s, METH_VARARGS, NULL},
	 { (char *)"glTexCoord4sv", _wrap_glTexCoord4sv, METH_VARARGS, NULL},
	 { (char *)"glVertex2d", _wrap_glVertex2d, METH_VARARGS, NULL},
	 { (char *)"glVertex2dv", _wrap_glVertex2dv, METH_VARARGS, NULL},
	 { (char *)"glVertex2f", _wrap_glVertex2f, METH_VARARGS, NULL},
	 { (char *)"glVertex2fv", _wrap_glVertex2fv, METH_VARARGS, NULL},
	 { (char *)"glVertex2i", _wrap_glVertex2i, METH_VARARGS, NULL},
	 { (char *)"glVertex2iv", _wrap_glVertex2iv, METH_VARARGS, NULL},
	 { (char *)"glVertex2s", _wrap_glVertex2s, METH_VARARGS, NULL},
	 { (char *)"glVertex2sv", _wrap_glVertex2sv, METH_VARARGS, NULL},
	 { (char *)"glVertex3d", _wrap_glVertex3d, METH_VARARGS, NULL},
	 { (char *)"glVertex3dv", _wrap_glVertex3dv, METH_VARARGS, NULL},
	 { (char *)"glVertex3f", _wrap_glVertex3f, METH_VARARGS, NULL},
	 { (char *)"glVertex3fv", _wrap_glVertex3fv, METH_VARARGS, NULL},
	 { (char *)"glVertex3i", _wrap_glVertex3i, METH_VARARGS, NULL},
	 { (char *)"glVertex3iv", _wrap_glVertex3iv, METH_VARARGS, NULL},
	 { (char *)"glVertex3s", _wrap_glVertex3s, METH_VARARGS, NULL},
	 { (char *)"glVertex3sv", _wrap_glVertex3sv, METH_VARARGS, NULL},
	 { (char *)"glVertex4d", _wrap_glVertex4d, METH_VARARGS, NULL},
	 { (char *)"glVertex4dv", _wrap_glVertex4dv, METH_VARARGS, NULL},
	 { (char *)"glVertex4f", _wrap_glVertex4f, METH_VARARGS, NULL},
	 { (char *)"glVertex4fv", _wrap_glVertex4fv, METH_VARARGS, NULL},
	 { (char *)"glVertex4i", _wrap_glVertex4i, METH_VARARGS, NULL},
	 { (char *)"glVertex4iv", _wrap_glVertex4iv, METH_VARARGS, NULL},
	 { (char *)"glVertex4s", _wrap_glVertex4s, METH_VARARGS, NULL},
	 { (char *)"glVertex4sv", _wrap_glVertex4sv, METH_VARARGS, NULL},
	 { (char *)"__has_extension", _wrap___has_extension, METH_VARARGS, NULL},
	 { (char *)"glAccum", _wrap_glAccum, METH_VARARGS, NULL},
	 { (char *)"glAlphaFunc", _wrap_glAlphaFunc, METH_VARARGS, NULL},
	 { (char *)"glAreTexturesResident", _wrap_glAreTexturesResident, METH_VARARGS, NULL},
	 { (char *)"glBindTexture", _wrap_glBindTexture, METH_VARARGS, NULL},
	 { (char *)"glBitmap", _wrap_glBitmap, METH_VARARGS, NULL},
	 { (char *)"glBlendFunc", _wrap_glBlendFunc, METH_VARARGS, NULL},
	 { (char *)"glClear", _wrap_glClear, METH_VARARGS, NULL},
	 { (char *)"glClearAccum", _wrap_glClearAccum, METH_VARARGS, NULL},
	 { (char *)"glClearColor", _wrap_glClearColor, METH_VARARGS, NULL},
	 { (char *)"glClearDepth", _wrap_glClearDepth, METH_VARARGS, NULL},
	 { (char *)"glClearIndex", _wrap_glClearIndex, METH_VARARGS, NULL},
	 { (char *)"glClearStencil", _wrap_glClearStencil, METH_VARARGS, NULL},
	 { (char *)"glClipPlane", _wrap_glClipPlane, METH_VARARGS, NULL},
	 { (char *)"glColorMask", _wrap_glColorMask, METH_VARARGS, NULL},
	 { (char *)"glColorMaterial", _wrap_glColorMaterial, METH_VARARGS, NULL},
	 { (char *)"glCopyPixels", _wrap_glCopyPixels, METH_VARARGS, NULL},
	 { (char *)"glCopyTexImage1D", _wrap_glCopyTexImage1D, METH_VARARGS, NULL},
	 { (char *)"glCopyTexImage2D", _wrap_glCopyTexImage2D, METH_VARARGS, NULL},
	 { (char *)"glCopyTexSubImage1D", _wrap_glCopyTexSubImage1D, METH_VARARGS, NULL},
	 { (char *)"glCopyTexSubImage2D", _wrap_glCopyTexSubImage2D, METH_VARARGS, NULL},
	 { (char *)"glCullFace", _wrap_glCullFace, METH_VARARGS, NULL},
	 { (char *)"glDeleteLists", _wrap_glDeleteLists, METH_VARARGS, NULL},
	 { (char *)"glDeleteTextures", _wrap_glDeleteTextures, METH_VARARGS, NULL},
	 { (char *)"glDepthFunc", _wrap_glDepthFunc, METH_VARARGS, NULL},
	 { (char *)"glDepthMask", _wrap_glDepthMask, METH_VARARGS, NULL},
	 { (char *)"glDepthRange", _wrap_glDepthRange, METH_VARARGS, NULL},
	 { (char *)"glDisable", _wrap_glDisable, METH_VARARGS, NULL},
	 { (char *)"glDisableClientState", _wrap_glDisableClientState, METH_VARARGS, NULL},
	 { (char *)"glDrawBuffer", _wrap_glDrawBuffer, METH_VARARGS, NULL},
	 { (char *)"glDrawPixels", _wrap_glDrawPixels, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsub", _wrap_glDrawPixelsub, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsb", _wrap_glDrawPixelsb, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsus", _wrap_glDrawPixelsus, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelss", _wrap_glDrawPixelss, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsui", _wrap_glDrawPixelsui, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsi", _wrap_glDrawPixelsi, METH_VARARGS, NULL},
	 { (char *)"glDrawPixelsf", _wrap_glDrawPixelsf, METH_VARARGS, NULL},
	 { (char *)"glEnable", _wrap_glEnable, METH_VARARGS, NULL},
	 { (char *)"glEnableClientState", _wrap_glEnableClientState, METH_VARARGS, NULL},
	 { (char *)"glEnd", _wrap_glEnd, METH_VARARGS, NULL},
	 { (char *)"glEndList", _wrap_glEndList, METH_VARARGS, NULL},
	 { (char *)"glEvalMesh1", _wrap_glEvalMesh1, METH_VARARGS, NULL},
	 { (char *)"glEvalMesh2", _wrap_glEvalMesh2, METH_VARARGS, NULL},
	 { (char *)"glFeedbackBuffer", _wrap_glFeedbackBuffer, METH_VARARGS, NULL},
	 { (char *)"glFinish", _wrap_glFinish, METH_VARARGS, NULL},
	 { (char *)"glFlush", _wrap_glFlush, METH_VARARGS, NULL},
	 { (char *)"glFogf", _wrap_glFogf, METH_VARARGS, NULL},
	 { (char *)"glFogfv", _wrap_glFogfv, METH_VARARGS, NULL},
	 { (char *)"glFogi", _wrap_glFogi, METH_VARARGS, NULL},
	 { (char *)"glFogiv", _wrap_glFogiv, METH_VARARGS, NULL},
	 { (char *)"glFrontFace", _wrap_glFrontFace, METH_VARARGS, NULL},
	 { (char *)"glFrustum", _wrap_glFrustum, METH_VARARGS, NULL},
	 { (char *)"glGenLists", _wrap_glGenLists, METH_VARARGS, NULL},
	 { (char *)"glGenTextures", _wrap_glGenTextures, METH_VARARGS, NULL},
	 { (char *)"glGetBooleanv", _wrap_glGetBooleanv, METH_VARARGS, NULL},
	 { (char *)"glGetClipPlane", _wrap_glGetClipPlane, METH_VARARGS, NULL},
	 { (char *)"glGetDoublev", _wrap_glGetDoublev, METH_VARARGS, NULL},
	 { (char *)"glGetFloatv", _wrap_glGetFloatv, METH_VARARGS, NULL},
	 { (char *)"glGetIntegerv", _wrap_glGetIntegerv, METH_VARARGS, NULL},
	 { (char *)"glGetLightfv", _wrap_glGetLightfv, METH_VARARGS, NULL},
	 { (char *)"glGetLightiv", _wrap_glGetLightiv, METH_VARARGS, NULL},
	 { (char *)"glGetMapdv", _wrap_glGetMapdv, METH_VARARGS, NULL},
	 { (char *)"glGetMapfv", _wrap_glGetMapfv, METH_VARARGS, NULL},
	 { (char *)"glGetMapiv", _wrap_glGetMapiv, METH_VARARGS, NULL},
	 { (char *)"glGetMaterialfv", _wrap_glGetMaterialfv, METH_VARARGS, NULL},
	 { (char *)"glGetMaterialiv", _wrap_glGetMaterialiv, METH_VARARGS, NULL},
	 { (char *)"glGetPixelMapfv", _wrap_glGetPixelMapfv, METH_VARARGS, NULL},
	 { (char *)"glGetPixelMapuiv", _wrap_glGetPixelMapuiv, METH_VARARGS, NULL},
	 { (char *)"glGetPixelMapusv", _wrap_glGetPixelMapusv, METH_VARARGS, NULL},
	 { (char *)"glGetPolygonStipple", _wrap_glGetPolygonStipple, METH_VARARGS, NULL},
	 { (char *)"glGetPolygonStippleub", _wrap_glGetPolygonStippleub, METH_VARARGS, NULL},
	 { (char *)"glGetString", _wrap_glGetString, METH_VARARGS, NULL},
	 { (char *)"glGetTexEnvfv", _wrap_glGetTexEnvfv, METH_VARARGS, NULL},
	 { (char *)"glGetTexEnviv", _wrap_glGetTexEnviv, METH_VARARGS, NULL},
	 { (char *)"glGetTexGendv", _wrap_glGetTexGendv, METH_VARARGS, NULL},
	 { (char *)"glGetTexGenfv", _wrap_glGetTexGenfv, METH_VARARGS, NULL},
	 { (char *)"glGetTexGeniv", _wrap_glGetTexGeniv, METH_VARARGS, NULL},
	 { (char *)"glGetTexImage", _wrap_glGetTexImage, METH_VARARGS, NULL},
	 { (char *)"glGetTexImageub", _wrap_glGetTexImageub, METH_VARARGS, NULL},
	 { (char *)"glGetTexImageb", _wrap_glGetTexImageb, METH_VARARGS, NULL},
	 { (char *)"glGetTexImageus", _wrap_glGetTexImageus, METH_VARARGS, NULL},
	 { (char *)"glGetTexImages", _wrap_glGetTexImages, METH_VARARGS, NULL},
	 { (char *)"glGetTexImageui", _wrap_glGetTexImageui, METH_VARARGS, NULL},
	 { (char *)"glGetTexImagei", _wrap_glGetTexImagei, METH_VARARGS, NULL},
	 { (char *)"glGetTexImagef", _wrap_glGetTexImagef, METH_VARARGS, NULL},
	 { (char *)"glGetTexImaged", _wrap_glGetTexImaged, METH_VARARGS, NULL},
	 { (char *)"glGetTexLevelParameterfv", _wrap_glGetTexLevelParameterfv, METH_VARARGS, NULL},
	 { (char *)"glGetTexLevelParameteriv", _wrap_glGetTexLevelParameteriv, METH_VARARGS, NULL},
	 { (char *)"glGetTexParameterfv", _wrap_glGetTexParameterfv, METH_VARARGS, NULL},
	 { (char *)"glGetTexParameteriv", _wrap_glGetTexParameteriv, METH_VARARGS, NULL},
	 { (char *)"glHint", _wrap_glHint, METH_VARARGS, NULL},
	 { (char *)"glIndexMask", _wrap_glIndexMask, METH_VARARGS, NULL},
	 { (char *)"glInitNames", _wrap_glInitNames, METH_VARARGS, NULL},
	 { (char *)"glIsEnabled", _wrap_glIsEnabled, METH_VARARGS, NULL},
	 { (char *)"glIsList", _wrap_glIsList, METH_VARARGS, NULL},
	 { (char *)"glIsTexture", _wrap_glIsTexture, METH_VARARGS, NULL},
	 { (char *)"glLightModelf", _wrap_glLightModelf, METH_VARARGS, NULL},
	 { (char *)"glLightModelfv", _wrap_glLightModelfv, METH_VARARGS, NULL},
	 { (char *)"glLightModeli", _wrap_glLightModeli, METH_VARARGS, NULL},
	 { (char *)"glLightModeliv", _wrap_glLightModeliv, METH_VARARGS, NULL},
	 { (char *)"glLightf", _wrap_glLightf, METH_VARARGS, NULL},
	 { (char *)"glLightfv", _wrap_glLightfv, METH_VARARGS, NULL},
	 { (char *)"glLighti", _wrap_glLighti, METH_VARARGS, NULL},
	 { (char *)"glLightiv", _wrap_glLightiv, METH_VARARGS, NULL},
	 { (char *)"glLineStipple", _wrap_glLineStipple, METH_VARARGS, NULL},
	 { (char *)"glLineWidth", _wrap_glLineWidth, METH_VARARGS, NULL},
	 { (char *)"glListBase", _wrap_glListBase, METH_VARARGS, NULL},
	 { (char *)"glLoadIdentity", _wrap_glLoadIdentity, METH_VARARGS, NULL},
	 { (char *)"glLoadMatrixd", _wrap_glLoadMatrixd, METH_VARARGS, NULL},
	 { (char *)"glLoadMatrixf", _wrap_glLoadMatrixf, METH_VARARGS, NULL},
	 { (char *)"glLoadName", _wrap_glLoadName, METH_VARARGS, NULL},
	 { (char *)"glLogicOp", _wrap_glLogicOp, METH_VARARGS, NULL},
	 { (char *)"glMap1d", _wrap_glMap1d, METH_VARARGS, NULL},
	 { (char *)"glMap1f", _wrap_glMap1f, METH_VARARGS, NULL},
	 { (char *)"glMap2d", _wrap_glMap2d, METH_VARARGS, NULL},
	 { (char *)"glMap2f", _wrap_glMap2f, METH_VARARGS, NULL},
	 { (char *)"glMapGrid1d", _wrap_glMapGrid1d, METH_VARARGS, NULL},
	 { (char *)"glMapGrid1f", _wrap_glMapGrid1f, METH_VARARGS, NULL},
	 { (char *)"glMapGrid2d", _wrap_glMapGrid2d, METH_VARARGS, NULL},
	 { (char *)"glMapGrid2f", _wrap_glMapGrid2f, METH_VARARGS, NULL},
	 { (char *)"glMatrixMode", _wrap_glMatrixMode, METH_VARARGS, NULL},
	 { (char *)"glMultMatrixd", _wrap_glMultMatrixd, METH_VARARGS, NULL},
	 { (char *)"glMultMatrixf", _wrap_glMultMatrixf, METH_VARARGS, NULL},
	 { (char *)"glNewList", _wrap_glNewList, METH_VARARGS, NULL},
	 { (char *)"glOrtho", _wrap_glOrtho, METH_VARARGS, NULL},
	 { (char *)"glPassThrough", _wrap_glPassThrough, METH_VARARGS, NULL},
	 { (char *)"glPixelMapfv", _wrap_glPixelMapfv, METH_VARARGS, NULL},
	 { (char *)"glPixelMapuiv", _wrap_glPixelMapuiv, METH_VARARGS, NULL},
	 { (char *)"glPixelMapusv", _wrap_glPixelMapusv, METH_VARARGS, NULL},
	 { (char *)"glPixelStoref", _wrap_glPixelStoref, METH_VARARGS, NULL},
	 { (char *)"glPixelStorei", _wrap_glPixelStorei, METH_VARARGS, NULL},
	 { (char *)"glPixelTransferf", _wrap_glPixelTransferf, METH_VARARGS, NULL},
	 { (char *)"glPixelTransferi", _wrap_glPixelTransferi, METH_VARARGS, NULL},
	 { (char *)"glPixelZoom", _wrap_glPixelZoom, METH_VARARGS, NULL},
	 { (char *)"glPointSize", _wrap_glPointSize, METH_VARARGS, NULL},
	 { (char *)"glPolygonMode", _wrap_glPolygonMode, METH_VARARGS, NULL},
	 { (char *)"glPolygonStipple", _wrap_glPolygonStipple, METH_VARARGS, NULL},
	 { (char *)"glPolygonStippleub", _wrap_glPolygonStippleub, METH_VARARGS, NULL},
	 { (char *)"glPopAttrib", _wrap_glPopAttrib, METH_VARARGS, NULL},
	 { (char *)"glPopClientAttrib", _wrap_glPopClientAttrib, METH_VARARGS, NULL},
	 { (char *)"glPopMatrix", _wrap_glPopMatrix, METH_VARARGS, NULL},
	 { (char *)"glPopName", _wrap_glPopName, METH_VARARGS, NULL},
	 { (char *)"glPrioritizeTextures", _wrap_glPrioritizeTextures, METH_VARARGS, NULL},
	 { (char *)"glPushAttrib", _wrap_glPushAttrib, METH_VARARGS, NULL},
	 { (char *)"glPushClientAttrib", _wrap_glPushClientAttrib, METH_VARARGS, NULL},
	 { (char *)"glPushMatrix", _wrap_glPushMatrix, METH_VARARGS, NULL},
	 { (char *)"glPushName", _wrap_glPushName, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2d", _wrap_glRasterPos2d, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2dv", _wrap_glRasterPos2dv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2f", _wrap_glRasterPos2f, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2fv", _wrap_glRasterPos2fv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2i", _wrap_glRasterPos2i, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2iv", _wrap_glRasterPos2iv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2s", _wrap_glRasterPos2s, METH_VARARGS, NULL},
	 { (char *)"glRasterPos2sv", _wrap_glRasterPos2sv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3d", _wrap_glRasterPos3d, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3dv", _wrap_glRasterPos3dv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3f", _wrap_glRasterPos3f, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3fv", _wrap_glRasterPos3fv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3i", _wrap_glRasterPos3i, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3iv", _wrap_glRasterPos3iv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3s", _wrap_glRasterPos3s, METH_VARARGS, NULL},
	 { (char *)"glRasterPos3sv", _wrap_glRasterPos3sv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4d", _wrap_glRasterPos4d, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4dv", _wrap_glRasterPos4dv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4f", _wrap_glRasterPos4f, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4fv", _wrap_glRasterPos4fv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4i", _wrap_glRasterPos4i, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4iv", _wrap_glRasterPos4iv, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4s", _wrap_glRasterPos4s, METH_VARARGS, NULL},
	 { (char *)"glRasterPos4sv", _wrap_glRasterPos4sv, METH_VARARGS, NULL},
	 { (char *)"glReadBuffer", _wrap_glReadBuffer, METH_VARARGS, NULL},
	 { (char *)"glReadPixels", _wrap_glReadPixels, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsub", _wrap_glReadPixelsub, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsb", _wrap_glReadPixelsb, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsus", _wrap_glReadPixelsus, METH_VARARGS, NULL},
	 { (char *)"glReadPixelss", _wrap_glReadPixelss, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsui", _wrap_glReadPixelsui, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsi", _wrap_glReadPixelsi, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsf", _wrap_glReadPixelsf, METH_VARARGS, NULL},
	 { (char *)"glReadPixelsd", _wrap_glReadPixelsd, METH_VARARGS, NULL},
	 { (char *)"glRectd", _wrap_glRectd, METH_VARARGS, NULL},
	 { (char *)"glRectdv", _wrap_glRectdv, METH_VARARGS, NULL},
	 { (char *)"glRectf", _wrap_glRectf, METH_VARARGS, NULL},
	 { (char *)"glRectfv", _wrap_glRectfv, METH_VARARGS, NULL},
	 { (char *)"glRecti", _wrap_glRecti, METH_VARARGS, NULL},
	 { (char *)"glRectiv", _wrap_glRectiv, METH_VARARGS, NULL},
	 { (char *)"glRects", _wrap_glRects, METH_VARARGS, NULL},
	 { (char *)"glRectsv", _wrap_glRectsv, METH_VARARGS, NULL},
	 { (char *)"glRenderMode", _wrap_glRenderMode, METH_VARARGS, NULL},
	 { (char *)"glRotated", _wrap_glRotated, METH_VARARGS, NULL},
	 { (char *)"glRotatef", _wrap_glRotatef, METH_VARARGS, NULL},
	 { (char *)"glScaled", _wrap_glScaled, METH_VARARGS, NULL},
	 { (char *)"glScalef", _wrap_glScalef, METH_VARARGS, NULL},
	 { (char *)"glScissor", _wrap_glScissor, METH_VARARGS, NULL},
	 { (char *)"glSelectBuffer", _wrap_glSelectBuffer, METH_VARARGS, NULL},
	 { (char *)"glShadeModel", _wrap_glShadeModel, METH_VARARGS, NULL},
	 { (char *)"glStencilFunc", _wrap_glStencilFunc, METH_VARARGS, NULL},
	 { (char *)"glStencilMask", _wrap_glStencilMask, METH_VARARGS, NULL},
	 { (char *)"glStencilOp", _wrap_glStencilOp, METH_VARARGS, NULL},
	 { (char *)"glTexEnvf", _wrap_glTexEnvf, METH_VARARGS, NULL},
	 { (char *)"glTexEnvfv", _wrap_glTexEnvfv, METH_VARARGS, NULL},
	 { (char *)"glTexEnvi", _wrap_glTexEnvi, METH_VARARGS, NULL},
	 { (char *)"glTexEnviv", _wrap_glTexEnviv, METH_VARARGS, NULL},
	 { (char *)"glTexGend", _wrap_glTexGend, METH_VARARGS, NULL},
	 { (char *)"glTexGendv", _wrap_glTexGendv, METH_VARARGS, NULL},
	 { (char *)"glTexGenf", _wrap_glTexGenf, METH_VARARGS, NULL},
	 { (char *)"glTexGenfv", _wrap_glTexGenfv, METH_VARARGS, NULL},
	 { (char *)"glTexGeni", _wrap_glTexGeni, METH_VARARGS, NULL},
	 { (char *)"glTexGeniv", _wrap_glTexGeniv, METH_VARARGS, NULL},
	 { (char *)"glTexImage1D", _wrap_glTexImage1D, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Dub", _wrap_glTexImage1Dub, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Db", _wrap_glTexImage1Db, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Dus", _wrap_glTexImage1Dus, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Ds", _wrap_glTexImage1Ds, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Dui", _wrap_glTexImage1Dui, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Di", _wrap_glTexImage1Di, METH_VARARGS, NULL},
	 { (char *)"glTexImage1Df", _wrap_glTexImage1Df, METH_VARARGS, NULL},
	 { (char *)"glTexImage2D", _wrap_glTexImage2D, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Dub", _wrap_glTexImage2Dub, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Db", _wrap_glTexImage2Db, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Dus", _wrap_glTexImage2Dus, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Ds", _wrap_glTexImage2Ds, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Dui", _wrap_glTexImage2Dui, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Di", _wrap_glTexImage2Di, METH_VARARGS, NULL},
	 { (char *)"glTexImage2Df", _wrap_glTexImage2Df, METH_VARARGS, NULL},
	 { (char *)"glTexParameterf", _wrap_glTexParameterf, METH_VARARGS, NULL},
	 { (char *)"glTexParameterfv", _wrap_glTexParameterfv, METH_VARARGS, NULL},
	 { (char *)"glTexParameteri", _wrap_glTexParameteri, METH_VARARGS, NULL},
	 { (char *)"glTexParameteriv", _wrap_glTexParameteriv, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1D", _wrap_glTexSubImage1D, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Dub", _wrap_glTexSubImage1Dub, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Db", _wrap_glTexSubImage1Db, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Dus", _wrap_glTexSubImage1Dus, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Ds", _wrap_glTexSubImage1Ds, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Dui", _wrap_glTexSubImage1Dui, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Di", _wrap_glTexSubImage1Di, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage1Df", _wrap_glTexSubImage1Df, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2D", _wrap_glTexSubImage2D, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Dub", _wrap_glTexSubImage2Dub, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Db", _wrap_glTexSubImage2Db, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Dus", _wrap_glTexSubImage2Dus, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Ds", _wrap_glTexSubImage2Ds, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Dui", _wrap_glTexSubImage2Dui, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Di", _wrap_glTexSubImage2Di, METH_VARARGS, NULL},
	 { (char *)"glTexSubImage2Df", _wrap_glTexSubImage2Df, METH_VARARGS, NULL},
	 { (char *)"glTranslated", _wrap_glTranslated, METH_VARARGS, NULL},
	 { (char *)"glTranslatef", _wrap_glTranslatef, METH_VARARGS, NULL},
	 { (char *)"glViewport", _wrap_glViewport, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_GLsizei[] = {{"_p_GLsizei", 0, "int *|GLsizei *", 0, 0, 0, 0},{"_p_GLint", 0, 0, 0, 0, 0, 0},{"_p_GLsizei", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLshort[] = {{"_p_GLshort", 0, "short *|GLshort *", 0, 0, 0, 0},{"_p_GLshort", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLboolean[] = {{"_p_GLboolean", 0, "unsigned char *|GLboolean *", 0, 0, 0, 0},{"_p_GLboolean", 0, 0, 0, 0, 0, 0},{"_p_GLubyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLushort[] = {{"_p_GLushort", 0, "unsigned short *|GLushort *", 0, 0, 0, 0},{"_p_GLushort", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLenum[] = {{"_p_GLenum", 0, "unsigned int *|GLenum *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLvoid[] = {{"_p_GLvoid", 0, "void *|GLvoid *", 0, 0, 0, 0},{"_p_GLvoid", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLint[] = {{"_p_GLint", 0, "int *|GLint *", 0, 0, 0, 0},{"_p_GLint", 0, 0, 0, 0, 0, 0},{"_p_GLsizei", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLclampd[] = {{"_p_GLclampd", 0, "double *|GLclampd *", 0, 0, 0, 0},{"_p_GLclampd", 0, 0, 0, 0, 0, 0},{"_p_GLdouble", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLclampf[] = {{"_p_GLclampf", 0, "float *|GLclampf *", 0, 0, 0, 0},{"_p_GLfloat", 0, 0, 0, 0, 0, 0},{"_p_GLclampf", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLuint[] = {{"_p_GLuint", 0, "unsigned int *|GLuint *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLbyte[] = {{"_p_GLbyte", 0, "signed char *|GLbyte *", 0, 0, 0, 0},{"_p_GLbyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLbitfield[] = {{"_p_GLbitfield", 0, "unsigned int *|GLbitfield *", 0, 0, 0, 0},{"_p_GLuint", 0, 0, 0, 0, 0, 0},{"_p_GLbitfield", 0, 0, 0, 0, 0, 0},{"_p_GLenum", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLfloat[] = {{"_p_GLfloat", 0, "float *|GLfloat *", 0, 0, 0, 0},{"_p_GLfloat", 0, 0, 0, 0, 0, 0},{"_p_GLclampf", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLubyte[] = {{"_p_GLubyte", 0, "unsigned char *|GLubyte *", 0, 0, 0, 0},{"_p_GLboolean", 0, 0, 0, 0, 0, 0},{"_p_GLubyte", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_GLdouble[] = {{"_p_GLdouble", 0, "double *|GLdouble *", 0, 0, 0, 0},{"_p_GLclampd", 0, 0, 0, 0, 0, 0},{"_p_GLdouble", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_GLsizei, 
_swigt__p_GLshort, 
_swigt__p_GLboolean, 
_swigt__size_t, 
_swigt__p_GLushort, 
_swigt__p_GLenum, 
_swigt__p_GLvoid, 
_swigt__p_GLint, 
_swigt__p_char, 
_swigt__p_GLclampd, 
_swigt__p_GLclampf, 
_swigt__p_GLuint, 
_swigt__ptrdiff_t, 
_swigt__p_GLbyte, 
_swigt__p_GLbitfield, 
_swigt__p_GLfloat, 
_swigt__p_GLubyte, 
_swigt__p_GLdouble, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{ SWIG_PY_POINTER, (char*)"__version__", 0, 0, (void *)"1.3.2.3", &SWIGTYPE_p_char},
{ SWIG_PY_POINTER, (char*)"__date__", 0, 0, (void *)"2004/11/14 23:19:04", &SWIGTYPE_p_char},
{ SWIG_PY_POINTER, (char*)"__author__", 0, 0, (void *)"Tarn Weisner Burton <twburton@users.sourceforge.net>\nMike C. Fletcher <mcfletch@users.sourceforge.net>", &SWIGTYPE_p_char},
{ SWIG_PY_POINTER, (char*)"__doc__", 0, 0, (void *)"For general information about OpenGL, including documentation, see http://www.opengl.org\n\nOther sites that might be useful include:\n    MSDN:  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/hh/opengl/openglstart_9uw5.asp?frame=true\n    Mesa3d:  http://www.mesa3d.org\n    OpenGL at Apple:  http://developer.apple.com/opengl", &SWIGTYPE_p_char},
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif


#ifdef SWIG_LINK_RUNTIME
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if defined(_MSC_VER) || defined(__GNUC__)
#    define SWIGIMPORT(a) extern a
#  else
#    if defined(__BORLANDC__)
#      define SWIGIMPORT(a) a _export
#    else
#      define SWIGIMPORT(a) a
#    endif
#  endif
#else
#  define SWIGIMPORT(a) a
#endif
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
#endif

#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) SWIG_init(void) {
    static PyObject *SWIG_globals = 0; 
    static int       typeinit = 0;
    PyObject *m, *d;
    int       i;
    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
    
    /* Fix SwigMethods to carry the callback ptrs when needed */
    SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
    
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
    d = PyModule_GetDict(m);
    
    if (!typeinit) {
#ifdef SWIG_LINK_RUNTIME
        swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
#else
#  ifndef SWIG_STATIC_RUNTIME
        SWIG_Python_LookupTypePointer(&swig_type_list_handle);
#  endif
#endif
        for (i = 0; swig_types_initial[i]; i++) {
            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        }
        typeinit = 1;
    }
    SWIG_InstallConstants(d,swig_const_table);
    
    PyDict_SetItemString(d,"__version__", SWIG_FromCharPtr("1.3.2.3"));
    PyDict_SetItemString(d,"__date__", SWIG_FromCharPtr("2004/11/14 23:19:04"));
    {
        PyDict_SetItemString(d,"__api_version__", SWIG_From_int((int)(256))); 
    }
    PyDict_SetItemString(d,"__author__", SWIG_FromCharPtr("Tarn Weisner Burton <twburton@users.sourceforge.net>\nMike C. Fletcher <mcfletch@users.sourceforge.net>"));
    PyDict_SetItemString(d,"__doc__", SWIG_FromCharPtr("For general information about OpenGL, including documentation, see http://www.opengl.org\n\nOther sites that might be useful include:\n    MSDN:  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/hh/opengl/openglstart_9uw5.asp?frame=true\n    Mesa3d:  http://www.mesa3d.org\n    OpenGL at Apple:  http://developer.apple.com/opengl"));
    
#ifdef NUMERIC
    PyArray_API = NULL;
    import_array();
    init_util();
    PyErr_Clear();
#endif
    
    
    GLerror = PyErr_NewException("OpenGL.GL.GLerror", PyExc_EnvironmentError, NULL);
    GLUerror = PyErr_NewException("OpenGL.GLU.GLUerror", PyExc_EnvironmentError, NULL);
#if HAS_DYNAMIC_EXT
    ProcAddresses = PyDict_New();
    PyDict_SetItemString(d, "proc", ProcAddresses);
#endif
#ifndef GL_VERSION_1_1
    contexts = PyDict_New();
#endif
    _util_API._decrement = decrementLock;
    _util_API._decrementPointer = decrementPointerLock;
    _util_API._incrementLock = incrementLock;
    _util_API._incrementPointerLock = incrementPointerLock;
    _util_API._acquire = acquire;
    _util_API._acquirePointer = acquirePointer;
    _util_API.InitExtension = InitExtension;
#if HAS_DYNAMIC_EXT
    _util_API.GL_GetProcAddress = GL_GetProcAddress;
#endif
    _util_API._GLerror = GLerror;
    _util_API._GLUerror = GLUerror;
    PyDict_SetItemString(d, "_util_API", PyCObject_FromVoidPtr((void*)&_util_API, NULL));
#ifdef NUMERIC
    PyDict_SetItemString(d, "__numeric_support__", PyInt_FromLong(1));
    PyDict_SetItemString(d, "__numeric_present__", PyInt_FromLong((PyArray_API) ? 1 : 0));
#else
    PyDict_SetItemString(d, "__numeric_support__", PyInt_FromLong(0));
    PyDict_SetItemString(d, "__numeric_present__", PyInt_FromLong(0));
#endif
    
    
    PyDict_SetItemString(d, "GLerror", GLerror);
    
    {
        PyDict_SetItemString(d,"GL_ACCUM", SWIG_From_int((int)(0x0100))); 
    }
    {
        PyDict_SetItemString(d,"GL_LOAD", SWIG_From_int((int)(0x0101))); 
    }
    {
        PyDict_SetItemString(d,"GL_RETURN", SWIG_From_int((int)(0x0102))); 
    }
    {
        PyDict_SetItemString(d,"GL_MULT", SWIG_From_int((int)(0x0103))); 
    }
    {
        PyDict_SetItemString(d,"GL_ADD", SWIG_From_int((int)(0x0104))); 
    }
    {
        PyDict_SetItemString(d,"GL_NEVER", SWIG_From_int((int)(0x0200))); 
    }
    {
        PyDict_SetItemString(d,"GL_LESS", SWIG_From_int((int)(0x0201))); 
    }
    {
        PyDict_SetItemString(d,"GL_EQUAL", SWIG_From_int((int)(0x0202))); 
    }
    {
        PyDict_SetItemString(d,"GL_LEQUAL", SWIG_From_int((int)(0x0203))); 
    }
    {
        PyDict_SetItemString(d,"GL_GREATER", SWIG_From_int((int)(0x0204))); 
    }
    {
        PyDict_SetItemString(d,"GL_NOTEQUAL", SWIG_From_int((int)(0x0205))); 
    }
    {
        PyDict_SetItemString(d,"GL_GEQUAL", SWIG_From_int((int)(0x0206))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALWAYS", SWIG_From_int((int)(0x0207))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_BIT", SWIG_From_int((int)(0x00000001))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_BIT", SWIG_From_int((int)(0x00000002))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_BIT", SWIG_From_int((int)(0x00000004))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_BIT", SWIG_From_int((int)(0x00000008))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_STIPPLE_BIT", SWIG_From_int((int)(0x00000010))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MODE_BIT", SWIG_From_int((int)(0x00000020))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHTING_BIT", SWIG_From_int((int)(0x00000040))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_BIT", SWIG_From_int((int)(0x00000080))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_BUFFER_BIT", SWIG_From_int((int)(0x00000100))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_BUFFER_BIT", SWIG_From_int((int)(0x00000200))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_BUFFER_BIT", SWIG_From_int((int)(0x00000400))); 
    }
    {
        PyDict_SetItemString(d,"GL_VIEWPORT_BIT", SWIG_From_int((int)(0x00000800))); 
    }
    {
        PyDict_SetItemString(d,"GL_TRANSFORM_BIT", SWIG_From_int((int)(0x00001000))); 
    }
    {
        PyDict_SetItemString(d,"GL_ENABLE_BIT", SWIG_From_int((int)(0x00002000))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_BUFFER_BIT", SWIG_From_int((int)(0x00004000))); 
    }
    {
        PyDict_SetItemString(d,"GL_HINT_BIT", SWIG_From_int((int)(0x00008000))); 
    }
    {
        PyDict_SetItemString(d,"GL_EVAL_BIT", SWIG_From_int((int)(0x00010000))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIST_BIT", SWIG_From_int((int)(0x00020000))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_BIT", SWIG_From_int((int)(0x00040000))); 
    }
    {
        PyDict_SetItemString(d,"GL_SCISSOR_BIT", SWIG_From_int((int)(0x00080000))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALL_ATTRIB_BITS", SWIG_From_int((int)(0x000fffff))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINTS", SWIG_From_int((int)(0x0000))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINES", SWIG_From_int((int)(0x0001))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_LOOP", SWIG_From_int((int)(0x0002))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_STRIP", SWIG_From_int((int)(0x0003))); 
    }
    {
        PyDict_SetItemString(d,"GL_TRIANGLES", SWIG_From_int((int)(0x0004))); 
    }
    {
        PyDict_SetItemString(d,"GL_TRIANGLE_STRIP", SWIG_From_int((int)(0x0005))); 
    }
    {
        PyDict_SetItemString(d,"GL_TRIANGLE_FAN", SWIG_From_int((int)(0x0006))); 
    }
    {
        PyDict_SetItemString(d,"GL_QUADS", SWIG_From_int((int)(0x0007))); 
    }
    {
        PyDict_SetItemString(d,"GL_QUAD_STRIP", SWIG_From_int((int)(0x0008))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON", SWIG_From_int((int)(0x0009))); 
    }
    {
        PyDict_SetItemString(d,"GL_ZERO", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"GL_ONE", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"GL_SRC_COLOR", SWIG_From_int((int)(0x0300))); 
    }
    {
        PyDict_SetItemString(d,"GL_ONE_MINUS_SRC_COLOR", SWIG_From_int((int)(0x0301))); 
    }
    {
        PyDict_SetItemString(d,"GL_SRC_ALPHA", SWIG_From_int((int)(0x0302))); 
    }
    {
        PyDict_SetItemString(d,"GL_ONE_MINUS_SRC_ALPHA", SWIG_From_int((int)(0x0303))); 
    }
    {
        PyDict_SetItemString(d,"GL_DST_ALPHA", SWIG_From_int((int)(0x0304))); 
    }
    {
        PyDict_SetItemString(d,"GL_ONE_MINUS_DST_ALPHA", SWIG_From_int((int)(0x0305))); 
    }
    {
        PyDict_SetItemString(d,"GL_DST_COLOR", SWIG_From_int((int)(0x0306))); 
    }
    {
        PyDict_SetItemString(d,"GL_ONE_MINUS_DST_COLOR", SWIG_From_int((int)(0x0307))); 
    }
    {
        PyDict_SetItemString(d,"GL_SRC_ALPHA_SATURATE", SWIG_From_int((int)(0x0308))); 
    }
    {
        PyDict_SetItemString(d,"GL_TRUE", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"GL_FALSE", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE0", SWIG_From_int((int)(0x3000))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE1", SWIG_From_int((int)(0x3001))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE2", SWIG_From_int((int)(0x3002))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE3", SWIG_From_int((int)(0x3003))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE4", SWIG_From_int((int)(0x3004))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIP_PLANE5", SWIG_From_int((int)(0x3005))); 
    }
    {
        PyDict_SetItemString(d,"GL_BYTE", SWIG_From_int((int)(0x1400))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNSIGNED_BYTE", SWIG_From_int((int)(0x1401))); 
    }
    {
        PyDict_SetItemString(d,"GL_SHORT", SWIG_From_int((int)(0x1402))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNSIGNED_SHORT", SWIG_From_int((int)(0x1403))); 
    }
    {
        PyDict_SetItemString(d,"GL_INT", SWIG_From_int((int)(0x1404))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNSIGNED_INT", SWIG_From_int((int)(0x1405))); 
    }
    {
        PyDict_SetItemString(d,"GL_FLOAT", SWIG_From_int((int)(0x1406))); 
    }
    {
        PyDict_SetItemString(d,"GL_2_BYTES", SWIG_From_int((int)(0x1407))); 
    }
    {
        PyDict_SetItemString(d,"GL_3_BYTES", SWIG_From_int((int)(0x1408))); 
    }
    {
        PyDict_SetItemString(d,"GL_4_BYTES", SWIG_From_int((int)(0x1409))); 
    }
    {
        PyDict_SetItemString(d,"GL_NONE", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"GL_FRONT_LEFT", SWIG_From_int((int)(0x0400))); 
    }
    {
        PyDict_SetItemString(d,"GL_FRONT_RIGHT", SWIG_From_int((int)(0x0401))); 
    }
    {
        PyDict_SetItemString(d,"GL_BACK_LEFT", SWIG_From_int((int)(0x0402))); 
    }
    {
        PyDict_SetItemString(d,"GL_BACK_RIGHT", SWIG_From_int((int)(0x0403))); 
    }
    {
        PyDict_SetItemString(d,"GL_FRONT", SWIG_From_int((int)(0x0404))); 
    }
    {
        PyDict_SetItemString(d,"GL_BACK", SWIG_From_int((int)(0x0405))); 
    }
    {
        PyDict_SetItemString(d,"GL_LEFT", SWIG_From_int((int)(0x0406))); 
    }
    {
        PyDict_SetItemString(d,"GL_RIGHT", SWIG_From_int((int)(0x0407))); 
    }
    {
        PyDict_SetItemString(d,"GL_FRONT_AND_BACK", SWIG_From_int((int)(0x0408))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUX0", SWIG_From_int((int)(0x0409))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUX1", SWIG_From_int((int)(0x040A))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUX2", SWIG_From_int((int)(0x040B))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUX3", SWIG_From_int((int)(0x040C))); 
    }
    {
        PyDict_SetItemString(d,"GL_NO_ERROR", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"GL_INVALID_ENUM", SWIG_From_int((int)(0x0500))); 
    }
    {
        PyDict_SetItemString(d,"GL_INVALID_VALUE", SWIG_From_int((int)(0x0501))); 
    }
    {
        PyDict_SetItemString(d,"GL_INVALID_OPERATION", SWIG_From_int((int)(0x0502))); 
    }
    {
        PyDict_SetItemString(d,"GL_STACK_OVERFLOW", SWIG_From_int((int)(0x0503))); 
    }
    {
        PyDict_SetItemString(d,"GL_STACK_UNDERFLOW", SWIG_From_int((int)(0x0504))); 
    }
    {
        PyDict_SetItemString(d,"GL_OUT_OF_MEMORY", SWIG_From_int((int)(0x0505))); 
    }
    {
        PyDict_SetItemString(d,"GL_2D", SWIG_From_int((int)(0x0600))); 
    }
    {
        PyDict_SetItemString(d,"GL_3D", SWIG_From_int((int)(0x0601))); 
    }
    {
        PyDict_SetItemString(d,"GL_3D_COLOR", SWIG_From_int((int)(0x0602))); 
    }
    {
        PyDict_SetItemString(d,"GL_3D_COLOR_TEXTURE", SWIG_From_int((int)(0x0603))); 
    }
    {
        PyDict_SetItemString(d,"GL_4D_COLOR_TEXTURE", SWIG_From_int((int)(0x0604))); 
    }
    {
        PyDict_SetItemString(d,"GL_PASS_THROUGH_TOKEN", SWIG_From_int((int)(0x0700))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_TOKEN", SWIG_From_int((int)(0x0701))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_TOKEN", SWIG_From_int((int)(0x0702))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_TOKEN", SWIG_From_int((int)(0x0703))); 
    }
    {
        PyDict_SetItemString(d,"GL_BITMAP_TOKEN", SWIG_From_int((int)(0x0704))); 
    }
    {
        PyDict_SetItemString(d,"GL_DRAW_PIXEL_TOKEN", SWIG_From_int((int)(0x0705))); 
    }
    {
        PyDict_SetItemString(d,"GL_COPY_PIXEL_TOKEN", SWIG_From_int((int)(0x0706))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_RESET_TOKEN", SWIG_From_int((int)(0x0707))); 
    }
    {
        PyDict_SetItemString(d,"GL_EXP", SWIG_From_int((int)(0x0800))); 
    }
    {
        PyDict_SetItemString(d,"GL_EXP2", SWIG_From_int((int)(0x0801))); 
    }
    {
        PyDict_SetItemString(d,"GL_CW", SWIG_From_int((int)(0x0900))); 
    }
    {
        PyDict_SetItemString(d,"GL_CCW", SWIG_From_int((int)(0x0901))); 
    }
    {
        PyDict_SetItemString(d,"GL_COEFF", SWIG_From_int((int)(0x0A00))); 
    }
    {
        PyDict_SetItemString(d,"GL_ORDER", SWIG_From_int((int)(0x0A01))); 
    }
    {
        PyDict_SetItemString(d,"GL_DOMAIN", SWIG_From_int((int)(0x0A02))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_COLOR", SWIG_From_int((int)(0x0B00))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_INDEX", SWIG_From_int((int)(0x0B01))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_NORMAL", SWIG_From_int((int)(0x0B02))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_TEXTURE_COORDS", SWIG_From_int((int)(0x0B03))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_COLOR", SWIG_From_int((int)(0x0B04))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_INDEX", SWIG_From_int((int)(0x0B05))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_TEXTURE_COORDS", SWIG_From_int((int)(0x0B06))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_POSITION", SWIG_From_int((int)(0x0B07))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_POSITION_VALID", SWIG_From_int((int)(0x0B08))); 
    }
    {
        PyDict_SetItemString(d,"GL_CURRENT_RASTER_DISTANCE", SWIG_From_int((int)(0x0B09))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_SMOOTH", SWIG_From_int((int)(0x0B10))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_SIZE", SWIG_From_int((int)(0x0B11))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_SIZE_RANGE", SWIG_From_int((int)(0x0B12))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_SIZE_GRANULARITY", SWIG_From_int((int)(0x0B13))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_SMOOTH", SWIG_From_int((int)(0x0B20))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_WIDTH", SWIG_From_int((int)(0x0B21))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_WIDTH_RANGE", SWIG_From_int((int)(0x0B22))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_WIDTH_GRANULARITY", SWIG_From_int((int)(0x0B23))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_STIPPLE", SWIG_From_int((int)(0x0B24))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_STIPPLE_PATTERN", SWIG_From_int((int)(0x0B25))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_STIPPLE_REPEAT", SWIG_From_int((int)(0x0B26))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIST_MODE", SWIG_From_int((int)(0x0B30))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_LIST_NESTING", SWIG_From_int((int)(0x0B31))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIST_BASE", SWIG_From_int((int)(0x0B32))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIST_INDEX", SWIG_From_int((int)(0x0B33))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_MODE", SWIG_From_int((int)(0x0B40))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_SMOOTH", SWIG_From_int((int)(0x0B41))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_STIPPLE", SWIG_From_int((int)(0x0B42))); 
    }
    {
        PyDict_SetItemString(d,"GL_EDGE_FLAG", SWIG_From_int((int)(0x0B43))); 
    }
    {
        PyDict_SetItemString(d,"GL_CULL_FACE", SWIG_From_int((int)(0x0B44))); 
    }
    {
        PyDict_SetItemString(d,"GL_CULL_FACE_MODE", SWIG_From_int((int)(0x0B45))); 
    }
    {
        PyDict_SetItemString(d,"GL_FRONT_FACE", SWIG_From_int((int)(0x0B46))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHTING", SWIG_From_int((int)(0x0B50))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT_MODEL_LOCAL_VIEWER", SWIG_From_int((int)(0x0B51))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT_MODEL_TWO_SIDE", SWIG_From_int((int)(0x0B52))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT_MODEL_AMBIENT", SWIG_From_int((int)(0x0B53))); 
    }
    {
        PyDict_SetItemString(d,"GL_SHADE_MODEL", SWIG_From_int((int)(0x0B54))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_MATERIAL_FACE", SWIG_From_int((int)(0x0B55))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_MATERIAL_PARAMETER", SWIG_From_int((int)(0x0B56))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_MATERIAL", SWIG_From_int((int)(0x0B57))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG", SWIG_From_int((int)(0x0B60))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_INDEX", SWIG_From_int((int)(0x0B61))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_DENSITY", SWIG_From_int((int)(0x0B62))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_START", SWIG_From_int((int)(0x0B63))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_END", SWIG_From_int((int)(0x0B64))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_MODE", SWIG_From_int((int)(0x0B65))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_COLOR", SWIG_From_int((int)(0x0B66))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_RANGE", SWIG_From_int((int)(0x0B70))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_TEST", SWIG_From_int((int)(0x0B71))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_WRITEMASK", SWIG_From_int((int)(0x0B72))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_CLEAR_VALUE", SWIG_From_int((int)(0x0B73))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_FUNC", SWIG_From_int((int)(0x0B74))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_CLEAR_VALUE", SWIG_From_int((int)(0x0B80))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_TEST", SWIG_From_int((int)(0x0B90))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_CLEAR_VALUE", SWIG_From_int((int)(0x0B91))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_FUNC", SWIG_From_int((int)(0x0B92))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_VALUE_MASK", SWIG_From_int((int)(0x0B93))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_FAIL", SWIG_From_int((int)(0x0B94))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_PASS_DEPTH_FAIL", SWIG_From_int((int)(0x0B95))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_PASS_DEPTH_PASS", SWIG_From_int((int)(0x0B96))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_REF", SWIG_From_int((int)(0x0B97))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_WRITEMASK", SWIG_From_int((int)(0x0B98))); 
    }
    {
        PyDict_SetItemString(d,"GL_MATRIX_MODE", SWIG_From_int((int)(0x0BA0))); 
    }
    {
        PyDict_SetItemString(d,"GL_NORMALIZE", SWIG_From_int((int)(0x0BA1))); 
    }
    {
        PyDict_SetItemString(d,"GL_VIEWPORT", SWIG_From_int((int)(0x0BA2))); 
    }
    {
        PyDict_SetItemString(d,"GL_MODELVIEW_STACK_DEPTH", SWIG_From_int((int)(0x0BA3))); 
    }
    {
        PyDict_SetItemString(d,"GL_PROJECTION_STACK_DEPTH", SWIG_From_int((int)(0x0BA4))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_STACK_DEPTH", SWIG_From_int((int)(0x0BA5))); 
    }
    {
        PyDict_SetItemString(d,"GL_MODELVIEW_MATRIX", SWIG_From_int((int)(0x0BA6))); 
    }
    {
        PyDict_SetItemString(d,"GL_PROJECTION_MATRIX", SWIG_From_int((int)(0x0BA7))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_MATRIX", SWIG_From_int((int)(0x0BA8))); 
    }
    {
        PyDict_SetItemString(d,"GL_ATTRIB_STACK_DEPTH", SWIG_From_int((int)(0x0BB0))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIENT_ATTRIB_STACK_DEPTH", SWIG_From_int((int)(0x0BB1))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_TEST", SWIG_From_int((int)(0x0BC0))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_TEST_FUNC", SWIG_From_int((int)(0x0BC1))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_TEST_REF", SWIG_From_int((int)(0x0BC2))); 
    }
    {
        PyDict_SetItemString(d,"GL_DITHER", SWIG_From_int((int)(0x0BD0))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLEND_DST", SWIG_From_int((int)(0x0BE0))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLEND_SRC", SWIG_From_int((int)(0x0BE1))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLEND", SWIG_From_int((int)(0x0BE2))); 
    }
    {
        PyDict_SetItemString(d,"GL_LOGIC_OP_MODE", SWIG_From_int((int)(0x0BF0))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_LOGIC_OP", SWIG_From_int((int)(0x0BF1))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_LOGIC_OP", SWIG_From_int((int)(0x0BF2))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUX_BUFFERS", SWIG_From_int((int)(0x0C00))); 
    }
    {
        PyDict_SetItemString(d,"GL_DRAW_BUFFER", SWIG_From_int((int)(0x0C01))); 
    }
    {
        PyDict_SetItemString(d,"GL_READ_BUFFER", SWIG_From_int((int)(0x0C02))); 
    }
    {
        PyDict_SetItemString(d,"GL_SCISSOR_BOX", SWIG_From_int((int)(0x0C10))); 
    }
    {
        PyDict_SetItemString(d,"GL_SCISSOR_TEST", SWIG_From_int((int)(0x0C11))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_CLEAR_VALUE", SWIG_From_int((int)(0x0C20))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_WRITEMASK", SWIG_From_int((int)(0x0C21))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_CLEAR_VALUE", SWIG_From_int((int)(0x0C22))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_WRITEMASK", SWIG_From_int((int)(0x0C23))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_MODE", SWIG_From_int((int)(0x0C30))); 
    }
    {
        PyDict_SetItemString(d,"GL_RGBA_MODE", SWIG_From_int((int)(0x0C31))); 
    }
    {
        PyDict_SetItemString(d,"GL_DOUBLEBUFFER", SWIG_From_int((int)(0x0C32))); 
    }
    {
        PyDict_SetItemString(d,"GL_STEREO", SWIG_From_int((int)(0x0C33))); 
    }
    {
        PyDict_SetItemString(d,"GL_RENDER_MODE", SWIG_From_int((int)(0x0C40))); 
    }
    {
        PyDict_SetItemString(d,"GL_PERSPECTIVE_CORRECTION_HINT", SWIG_From_int((int)(0x0C50))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT_SMOOTH_HINT", SWIG_From_int((int)(0x0C51))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE_SMOOTH_HINT", SWIG_From_int((int)(0x0C52))); 
    }
    {
        PyDict_SetItemString(d,"GL_POLYGON_SMOOTH_HINT", SWIG_From_int((int)(0x0C53))); 
    }
    {
        PyDict_SetItemString(d,"GL_FOG_HINT", SWIG_From_int((int)(0x0C54))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_GEN_S", SWIG_From_int((int)(0x0C60))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_GEN_T", SWIG_From_int((int)(0x0C61))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_GEN_R", SWIG_From_int((int)(0x0C62))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_GEN_Q", SWIG_From_int((int)(0x0C63))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_I", SWIG_From_int((int)(0x0C70))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_S_TO_S", SWIG_From_int((int)(0x0C71))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_R", SWIG_From_int((int)(0x0C72))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_G", SWIG_From_int((int)(0x0C73))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_B", SWIG_From_int((int)(0x0C74))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_A", SWIG_From_int((int)(0x0C75))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_R_TO_R", SWIG_From_int((int)(0x0C76))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_G_TO_G", SWIG_From_int((int)(0x0C77))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_B_TO_B", SWIG_From_int((int)(0x0C78))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_A_TO_A", SWIG_From_int((int)(0x0C79))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_I_SIZE", SWIG_From_int((int)(0x0CB0))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_S_TO_S_SIZE", SWIG_From_int((int)(0x0CB1))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_R_SIZE", SWIG_From_int((int)(0x0CB2))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_G_SIZE", SWIG_From_int((int)(0x0CB3))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_B_SIZE", SWIG_From_int((int)(0x0CB4))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_I_TO_A_SIZE", SWIG_From_int((int)(0x0CB5))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_R_TO_R_SIZE", SWIG_From_int((int)(0x0CB6))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_G_TO_G_SIZE", SWIG_From_int((int)(0x0CB7))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_B_TO_B_SIZE", SWIG_From_int((int)(0x0CB8))); 
    }
    {
        PyDict_SetItemString(d,"GL_PIXEL_MAP_A_TO_A_SIZE", SWIG_From_int((int)(0x0CB9))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_SWAP_BYTES", SWIG_From_int((int)(0x0CF0))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_LSB_FIRST", SWIG_From_int((int)(0x0CF1))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_ROW_LENGTH", SWIG_From_int((int)(0x0CF2))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_SKIP_ROWS", SWIG_From_int((int)(0x0CF3))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_SKIP_PIXELS", SWIG_From_int((int)(0x0CF4))); 
    }
    {
        PyDict_SetItemString(d,"GL_UNPACK_ALIGNMENT", SWIG_From_int((int)(0x0CF5))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_SWAP_BYTES", SWIG_From_int((int)(0x0D00))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_LSB_FIRST", SWIG_From_int((int)(0x0D01))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_ROW_LENGTH", SWIG_From_int((int)(0x0D02))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_SKIP_ROWS", SWIG_From_int((int)(0x0D03))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_SKIP_PIXELS", SWIG_From_int((int)(0x0D04))); 
    }
    {
        PyDict_SetItemString(d,"GL_PACK_ALIGNMENT", SWIG_From_int((int)(0x0D05))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP_COLOR", SWIG_From_int((int)(0x0D10))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP_STENCIL", SWIG_From_int((int)(0x0D11))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_SHIFT", SWIG_From_int((int)(0x0D12))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_OFFSET", SWIG_From_int((int)(0x0D13))); 
    }
    {
        PyDict_SetItemString(d,"GL_RED_SCALE", SWIG_From_int((int)(0x0D14))); 
    }
    {
        PyDict_SetItemString(d,"GL_RED_BIAS", SWIG_From_int((int)(0x0D15))); 
    }
    {
        PyDict_SetItemString(d,"GL_ZOOM_X", SWIG_From_int((int)(0x0D16))); 
    }
    {
        PyDict_SetItemString(d,"GL_ZOOM_Y", SWIG_From_int((int)(0x0D17))); 
    }
    {
        PyDict_SetItemString(d,"GL_GREEN_SCALE", SWIG_From_int((int)(0x0D18))); 
    }
    {
        PyDict_SetItemString(d,"GL_GREEN_BIAS", SWIG_From_int((int)(0x0D19))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLUE_SCALE", SWIG_From_int((int)(0x0D1A))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLUE_BIAS", SWIG_From_int((int)(0x0D1B))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_SCALE", SWIG_From_int((int)(0x0D1C))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_BIAS", SWIG_From_int((int)(0x0D1D))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_SCALE", SWIG_From_int((int)(0x0D1E))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_BIAS", SWIG_From_int((int)(0x0D1F))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_EVAL_ORDER", SWIG_From_int((int)(0x0D30))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_LIGHTS", SWIG_From_int((int)(0x0D31))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_CLIP_PLANES", SWIG_From_int((int)(0x0D32))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_TEXTURE_SIZE", SWIG_From_int((int)(0x0D33))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_PIXEL_MAP_TABLE", SWIG_From_int((int)(0x0D34))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_ATTRIB_STACK_DEPTH", SWIG_From_int((int)(0x0D35))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_MODELVIEW_STACK_DEPTH", SWIG_From_int((int)(0x0D36))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_NAME_STACK_DEPTH", SWIG_From_int((int)(0x0D37))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_PROJECTION_STACK_DEPTH", SWIG_From_int((int)(0x0D38))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_TEXTURE_STACK_DEPTH", SWIG_From_int((int)(0x0D39))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_VIEWPORT_DIMS", SWIG_From_int((int)(0x0D3A))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", SWIG_From_int((int)(0x0D3B))); 
    }
    {
        PyDict_SetItemString(d,"GL_SUBPIXEL_BITS", SWIG_From_int((int)(0x0D50))); 
    }
    {
        PyDict_SetItemString(d,"GL_INDEX_BITS", SWIG_From_int((int)(0x0D51))); 
    }
    {
        PyDict_SetItemString(d,"GL_RED_BITS", SWIG_From_int((int)(0x0D52))); 
    }
    {
        PyDict_SetItemString(d,"GL_GREEN_BITS", SWIG_From_int((int)(0x0D53))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLUE_BITS", SWIG_From_int((int)(0x0D54))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA_BITS", SWIG_From_int((int)(0x0D55))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_BITS", SWIG_From_int((int)(0x0D56))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_BITS", SWIG_From_int((int)(0x0D57))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_RED_BITS", SWIG_From_int((int)(0x0D58))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_GREEN_BITS", SWIG_From_int((int)(0x0D59))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_BLUE_BITS", SWIG_From_int((int)(0x0D5A))); 
    }
    {
        PyDict_SetItemString(d,"GL_ACCUM_ALPHA_BITS", SWIG_From_int((int)(0x0D5B))); 
    }
    {
        PyDict_SetItemString(d,"GL_NAME_STACK_DEPTH", SWIG_From_int((int)(0x0D70))); 
    }
    {
        PyDict_SetItemString(d,"GL_AUTO_NORMAL", SWIG_From_int((int)(0x0D80))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_COLOR_4", SWIG_From_int((int)(0x0D90))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_INDEX", SWIG_From_int((int)(0x0D91))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_NORMAL", SWIG_From_int((int)(0x0D92))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_1", SWIG_From_int((int)(0x0D93))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_2", SWIG_From_int((int)(0x0D94))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_3", SWIG_From_int((int)(0x0D95))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_TEXTURE_COORD_4", SWIG_From_int((int)(0x0D96))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_VERTEX_3", SWIG_From_int((int)(0x0D97))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_VERTEX_4", SWIG_From_int((int)(0x0D98))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_COLOR_4", SWIG_From_int((int)(0x0DB0))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_INDEX", SWIG_From_int((int)(0x0DB1))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_NORMAL", SWIG_From_int((int)(0x0DB2))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_1", SWIG_From_int((int)(0x0DB3))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_2", SWIG_From_int((int)(0x0DB4))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_3", SWIG_From_int((int)(0x0DB5))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_TEXTURE_COORD_4", SWIG_From_int((int)(0x0DB6))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_VERTEX_3", SWIG_From_int((int)(0x0DB7))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_VERTEX_4", SWIG_From_int((int)(0x0DB8))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_GRID_DOMAIN", SWIG_From_int((int)(0x0DD0))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP1_GRID_SEGMENTS", SWIG_From_int((int)(0x0DD1))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_GRID_DOMAIN", SWIG_From_int((int)(0x0DD2))); 
    }
    {
        PyDict_SetItemString(d,"GL_MAP2_GRID_SEGMENTS", SWIG_From_int((int)(0x0DD3))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_1D", SWIG_From_int((int)(0x0DE0))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_2D", SWIG_From_int((int)(0x0DE1))); 
    }
    {
        PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_POINTER", SWIG_From_int((int)(0x0DF0))); 
    }
    {
        PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_SIZE", SWIG_From_int((int)(0x0DF1))); 
    }
    {
        PyDict_SetItemString(d,"GL_FEEDBACK_BUFFER_TYPE", SWIG_From_int((int)(0x0DF2))); 
    }
    {
        PyDict_SetItemString(d,"GL_SELECTION_BUFFER_POINTER", SWIG_From_int((int)(0x0DF3))); 
    }
    {
        PyDict_SetItemString(d,"GL_SELECTION_BUFFER_SIZE", SWIG_From_int((int)(0x0DF4))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_WIDTH", SWIG_From_int((int)(0x1000))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_HEIGHT", SWIG_From_int((int)(0x1001))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_INTERNAL_FORMAT", SWIG_From_int((int)(0x1003))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_BORDER_COLOR", SWIG_From_int((int)(0x1004))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_BORDER", SWIG_From_int((int)(0x1005))); 
    }
    {
        PyDict_SetItemString(d,"GL_DONT_CARE", SWIG_From_int((int)(0x1100))); 
    }
    {
        PyDict_SetItemString(d,"GL_FASTEST", SWIG_From_int((int)(0x1101))); 
    }
    {
        PyDict_SetItemString(d,"GL_NICEST", SWIG_From_int((int)(0x1102))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT0", SWIG_From_int((int)(0x4000))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT1", SWIG_From_int((int)(0x4001))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT2", SWIG_From_int((int)(0x4002))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT3", SWIG_From_int((int)(0x4003))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT4", SWIG_From_int((int)(0x4004))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT5", SWIG_From_int((int)(0x4005))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT6", SWIG_From_int((int)(0x4006))); 
    }
    {
        PyDict_SetItemString(d,"GL_LIGHT7", SWIG_From_int((int)(0x4007))); 
    }
    {
        PyDict_SetItemString(d,"GL_AMBIENT", SWIG_From_int((int)(0x1200))); 
    }
    {
        PyDict_SetItemString(d,"GL_DIFFUSE", SWIG_From_int((int)(0x1201))); 
    }
    {
        PyDict_SetItemString(d,"GL_SPECULAR", SWIG_From_int((int)(0x1202))); 
    }
    {
        PyDict_SetItemString(d,"GL_POSITION", SWIG_From_int((int)(0x1203))); 
    }
    {
        PyDict_SetItemString(d,"GL_SPOT_DIRECTION", SWIG_From_int((int)(0x1204))); 
    }
    {
        PyDict_SetItemString(d,"GL_SPOT_EXPONENT", SWIG_From_int((int)(0x1205))); 
    }
    {
        PyDict_SetItemString(d,"GL_SPOT_CUTOFF", SWIG_From_int((int)(0x1206))); 
    }
    {
        PyDict_SetItemString(d,"GL_CONSTANT_ATTENUATION", SWIG_From_int((int)(0x1207))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINEAR_ATTENUATION", SWIG_From_int((int)(0x1208))); 
    }
    {
        PyDict_SetItemString(d,"GL_QUADRATIC_ATTENUATION", SWIG_From_int((int)(0x1209))); 
    }
    {
        PyDict_SetItemString(d,"GL_COMPILE", SWIG_From_int((int)(0x1300))); 
    }
    {
        PyDict_SetItemString(d,"GL_COMPILE_AND_EXECUTE", SWIG_From_int((int)(0x1301))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLEAR", SWIG_From_int((int)(0x1500))); 
    }
    {
        PyDict_SetItemString(d,"GL_AND", SWIG_From_int((int)(0x1501))); 
    }
    {
        PyDict_SetItemString(d,"GL_AND_REVERSE", SWIG_From_int((int)(0x1502))); 
    }
    {
        PyDict_SetItemString(d,"GL_COPY", SWIG_From_int((int)(0x1503))); 
    }
    {
        PyDict_SetItemString(d,"GL_AND_INVERTED", SWIG_From_int((int)(0x1504))); 
    }
    {
        PyDict_SetItemString(d,"GL_NOOP", SWIG_From_int((int)(0x1505))); 
    }
    {
        PyDict_SetItemString(d,"GL_XOR", SWIG_From_int((int)(0x1506))); 
    }
    {
        PyDict_SetItemString(d,"GL_OR", SWIG_From_int((int)(0x1507))); 
    }
    {
        PyDict_SetItemString(d,"GL_NOR", SWIG_From_int((int)(0x1508))); 
    }
    {
        PyDict_SetItemString(d,"GL_EQUIV", SWIG_From_int((int)(0x1509))); 
    }
    {
        PyDict_SetItemString(d,"GL_INVERT", SWIG_From_int((int)(0x150A))); 
    }
    {
        PyDict_SetItemString(d,"GL_OR_REVERSE", SWIG_From_int((int)(0x150B))); 
    }
    {
        PyDict_SetItemString(d,"GL_COPY_INVERTED", SWIG_From_int((int)(0x150C))); 
    }
    {
        PyDict_SetItemString(d,"GL_OR_INVERTED", SWIG_From_int((int)(0x150D))); 
    }
    {
        PyDict_SetItemString(d,"GL_NAND", SWIG_From_int((int)(0x150E))); 
    }
    {
        PyDict_SetItemString(d,"GL_SET", SWIG_From_int((int)(0x150F))); 
    }
    {
        PyDict_SetItemString(d,"GL_EMISSION", SWIG_From_int((int)(0x1600))); 
    }
    {
        PyDict_SetItemString(d,"GL_SHININESS", SWIG_From_int((int)(0x1601))); 
    }
    {
        PyDict_SetItemString(d,"GL_AMBIENT_AND_DIFFUSE", SWIG_From_int((int)(0x1602))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_INDEXES", SWIG_From_int((int)(0x1603))); 
    }
    {
        PyDict_SetItemString(d,"GL_MODELVIEW", SWIG_From_int((int)(0x1700))); 
    }
    {
        PyDict_SetItemString(d,"GL_PROJECTION", SWIG_From_int((int)(0x1701))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE", SWIG_From_int((int)(0x1702))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR", SWIG_From_int((int)(0x1800))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH", SWIG_From_int((int)(0x1801))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL", SWIG_From_int((int)(0x1802))); 
    }
    {
        PyDict_SetItemString(d,"GL_COLOR_INDEX", SWIG_From_int((int)(0x1900))); 
    }
    {
        PyDict_SetItemString(d,"GL_STENCIL_INDEX", SWIG_From_int((int)(0x1901))); 
    }
    {
        PyDict_SetItemString(d,"GL_DEPTH_COMPONENT", SWIG_From_int((int)(0x1902))); 
    }
    {
        PyDict_SetItemString(d,"GL_RED", SWIG_From_int((int)(0x1903))); 
    }
    {
        PyDict_SetItemString(d,"GL_GREEN", SWIG_From_int((int)(0x1904))); 
    }
    {
        PyDict_SetItemString(d,"GL_BLUE", SWIG_From_int((int)(0x1905))); 
    }
    {
        PyDict_SetItemString(d,"GL_ALPHA", SWIG_From_int((int)(0x1906))); 
    }
    {
        PyDict_SetItemString(d,"GL_RGB", SWIG_From_int((int)(0x1907))); 
    }
    {
        PyDict_SetItemString(d,"GL_RGBA", SWIG_From_int((int)(0x1908))); 
    }
    {
        PyDict_SetItemString(d,"GL_LUMINANCE", SWIG_From_int((int)(0x1909))); 
    }
    {
        PyDict_SetItemString(d,"GL_LUMINANCE_ALPHA", SWIG_From_int((int)(0x190A))); 
    }
    {
        PyDict_SetItemString(d,"GL_BITMAP", SWIG_From_int((int)(0x1A00))); 
    }
    {
        PyDict_SetItemString(d,"GL_POINT", SWIG_From_int((int)(0x1B00))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINE", SWIG_From_int((int)(0x1B01))); 
    }
    {
        PyDict_SetItemString(d,"GL_FILL", SWIG_From_int((int)(0x1B02))); 
    }
    {
        PyDict_SetItemString(d,"GL_RENDER", SWIG_From_int((int)(0x1C00))); 
    }
    {
        PyDict_SetItemString(d,"GL_FEEDBACK", SWIG_From_int((int)(0x1C01))); 
    }
    {
        PyDict_SetItemString(d,"GL_SELECT", SWIG_From_int((int)(0x1C02))); 
    }
    {
        PyDict_SetItemString(d,"GL_FLAT", SWIG_From_int((int)(0x1D00))); 
    }
    {
        PyDict_SetItemString(d,"GL_SMOOTH", SWIG_From_int((int)(0x1D01))); 
    }
    {
        PyDict_SetItemString(d,"GL_KEEP", SWIG_From_int((int)(0x1E00))); 
    }
    {
        PyDict_SetItemString(d,"GL_REPLACE", SWIG_From_int((int)(0x1E01))); 
    }
    {
        PyDict_SetItemString(d,"GL_INCR", SWIG_From_int((int)(0x1E02))); 
    }
    {
        PyDict_SetItemString(d,"GL_DECR", SWIG_From_int((int)(0x1E03))); 
    }
    {
        PyDict_SetItemString(d,"GL_VENDOR", SWIG_From_int((int)(0x1F00))); 
    }
    {
        PyDict_SetItemString(d,"GL_RENDERER", SWIG_From_int((int)(0x1F01))); 
    }
    {
        PyDict_SetItemString(d,"GL_VERSION", SWIG_From_int((int)(0x1F02))); 
    }
    {
        PyDict_SetItemString(d,"GL_EXTENSIONS", SWIG_From_int((int)(0x1F03))); 
    }
    {
        PyDict_SetItemString(d,"GL_S", SWIG_From_int((int)(0x2000))); 
    }
    {
        PyDict_SetItemString(d,"GL_T", SWIG_From_int((int)(0x2001))); 
    }
    {
        PyDict_SetItemString(d,"GL_R", SWIG_From_int((int)(0x2002))); 
    }
    {
        PyDict_SetItemString(d,"GL_Q", SWIG_From_int((int)(0x2003))); 
    }
    {
        PyDict_SetItemString(d,"GL_MODULATE", SWIG_From_int((int)(0x2100))); 
    }
    {
        PyDict_SetItemString(d,"GL_DECAL", SWIG_From_int((int)(0x2101))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_ENV_MODE", SWIG_From_int((int)(0x2200))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_ENV_COLOR", SWIG_From_int((int)(0x2201))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_ENV", SWIG_From_int((int)(0x2300))); 
    }
    {
        PyDict_SetItemString(d,"GL_EYE_LINEAR", SWIG_From_int((int)(0x2400))); 
    }
    {
        PyDict_SetItemString(d,"GL_OBJECT_LINEAR", SWIG_From_int((int)(0x2401))); 
    }
    {
        PyDict_SetItemString(d,"GL_SPHERE_MAP", SWIG_From_int((int)(0x2402))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_GEN_MODE", SWIG_From_int((int)(0x2500))); 
    }
    {
        PyDict_SetItemString(d,"GL_OBJECT_PLANE", SWIG_From_int((int)(0x2501))); 
    }
    {
        PyDict_SetItemString(d,"GL_EYE_PLANE", SWIG_From_int((int)(0x2502))); 
    }
    {
        PyDict_SetItemString(d,"GL_NEAREST", SWIG_From_int((int)(0x2600))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINEAR", SWIG_From_int((int)(0x2601))); 
    }
    {
        PyDict_SetItemString(d,"GL_NEAREST_MIPMAP_NEAREST", SWIG_From_int((int)(0x2700))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINEAR_MIPMAP_NEAREST", SWIG_From_int((int)(0x2701))); 
    }
    {
        PyDict_SetItemString(d,"GL_NEAREST_MIPMAP_LINEAR", SWIG_From_int((int)(0x2702))); 
    }
    {
        PyDict_SetItemString(d,"GL_LINEAR_MIPMAP_LINEAR", SWIG_From_int((int)(0x2703))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_MAG_FILTER", SWIG_From_int((int)(0x2800))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_MIN_FILTER", SWIG_From_int((int)(0x2801))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_WRAP_S", SWIG_From_int((int)(0x2802))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_WRAP_T", SWIG_From_int((int)(0x2803))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLAMP", SWIG_From_int((int)(0x2900))); 
    }
    {
        PyDict_SetItemString(d,"GL_REPEAT", SWIG_From_int((int)(0x2901))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIENT_PIXEL_STORE_BIT", SWIG_From_int((int)(0x00000001))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIENT_VERTEX_ARRAY_BIT", SWIG_From_int((int)(0x00000002))); 
    }
    {
        PyDict_SetItemString(d,"GL_CLIENT_ALL_ATTRIB_BITS", SWIG_From_int((int)(0xffffffff))); 
    }
    {
        PyDict_SetItemString(d,"GL_LOGIC_OP", SWIG_From_int((int)(0x0BF1))); 
    }
    {
        PyDict_SetItemString(d,"GL_TEXTURE_COMPONENTS", SWIG_From_int((int)(0x1003))); 
    }
}