/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.13u-20020617-2210
 * 
 * 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
/***********************************************************************
 * 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__)
#       if defined(_MSC_VER)
#               if defined(STATIC_LINKED)
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) extern a
#               else
#                       define SWIGEXPORT(a) __declspec(dllexport) a
#                       define SWIGIMPORT(a) extern a
#               endif
#       else
#               if defined(__BORLANDC__)
#                       define SWIGEXPORT(a) a _export
#                       define SWIGIMPORT(a) a _export
#               else
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) a
#               endif
#       endif
#else
#       define SWIGEXPORT(a) a
#       define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGRUNTIME(a) static a
#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;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
  void                   *clientdata;	
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(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;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = 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++;
  }
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(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 */
  while (s) {
    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;
      return s;
    }
    s = s->next;
  }
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(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 */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) 
{
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
     ty = (*ty->dcast)(ptr);
     if (ty) lastty = ty;
  }
  return lastty;
}

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

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

#ifdef __cplusplus
}

#endif

/***********************************************************************
 * python.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)
 ************************************************************************/

#include <stdlib.h>
#include "Python.h"

#ifdef __cplusplus
extern "C" {
#endif

#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;

#ifdef SWIG_NOINCLUDE

SWIGEXPORT(PyObject *)        SWIG_newvarlink();
SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
#else

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

typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

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

statichere PyTypeObject varlinktype = {
  PyObject_HEAD_INIT(0)              
  0,
  (char *)"swigvarlink",                      /* Type name    */
  sizeof(swig_varlinkobject),         /* Basic size   */
  0,                                  /* Itemsize     */
  0,                                  /* Deallocator  */ 
  (printfunc) swig_varlink_print,     /* Print        */
  (getattrfunc) swig_varlink_getattr, /* get attr     */
  (setattrfunc) swig_varlink_setattr, /* Set attr     */
  0,                                  /* tp_compare   */
  (reprfunc) swig_varlink_repr,       /* tp_repr      */    
  0,                                  /* tp_as_number */
  0,                                  /* tp_as_mapping*/
  0,                                  /* tp_hash      */
};

/* Create a variable linking object for use later */
SWIGRUNTIME(PyObject *)
SWIG_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);
}

SWIGRUNTIME(void)
SWIG_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;
}

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

/* Unpack binary data from a string */
SWIGRUNTIME(char *)
SWIG_UnpackData(char *c, void *ptr, int sz) {
  register unsigned char uu = 0;
  register int d;
  unsigned char *u = (unsigned char *) ptr;
  int i;
  for (i = 0; i < sz; i++, 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;
}

/* Convert a pointer value */
SWIGRUNTIME(int)
SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;
  static PyObject *SWIG_this = 0;
  int    newref = 0;

  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_InternFromString("this");
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyCObject_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  *ptr = PyCObject_AsVoidPtr(obj);
  c = (char *) PyCObject_GetDesc(obj);
  if (newref) Py_DECREF(obj);
  goto cobject;
#else
  if (!(PyString_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_InternFromString("this");
    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_AsString(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') {
    *ptr = (void *) 0;
    if (strcmp(c,"NULL") == 0) {
      if (newref) { Py_DECREF(obj); }
      return 0;
    } else {
      if (newref) { Py_DECREF(obj); }
      goto type_error;
    }
  }
  c++;
  c = SWIG_UnpackData(c,ptr,sizeof(void *));
  if (newref) { Py_DECREF(obj); }
#endif

#ifdef SWIG_COBJECT_TYPES
cobject:
#endif

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

type_error:
  if (flags) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Convert a packed value value */
SWIGRUNTIME(int)
SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;

  if ((!obj) || (!PyString_Check(obj))) goto type_error;
  c = PyString_AsString(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:

  if (flags) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Create a new pointer object */
SWIGRUNTIME(PyObject *)
SWIG_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];
    char *r = result;
    *(r++) = '_';
    r = SWIG_PackData(r,&ptr,sizeof(void *));
    strcpy(r,type->name);
    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 (own) {
      PyObject *n = PyInt_FromLong(1);
      PyObject_SetAttrString(inst,(char*)"thisown",n);
      Py_DECREF(n);
    }
    robj = inst;
  }
  return robj;
}

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

/* Install Constants */
SWIGRUNTIME(void)
SWIG_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:
      obj = PyString_FromString((char *) constants[i].pvalue);
      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);
    }
  }
}

#endif

#ifdef __cplusplus
}
#endif








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

static swig_type_info *swig_types[1];

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


/*-----------------------------------------------
              @(target):= GL__init___.so
  ------------------------------------------------*/
#define SWIG_init    initGL__init___

#define SWIG_name    "GL__init___"


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



 static char _doc_glArrayElement[] = "glArrayElement(i) -> None"; 
 static char _doc_glBegin[] = "glBegin(mode) -> None"; 
 static char _doc_glCallList[] = "glCallList(list) -> None"; 
 static char _doc_glCallLists[] = "glCallLists(lists[]) -> None"; 
 static char _doc_glColor3b[] = "glColor3b(red, green, blue) -> None"; 
 static char _doc_glColor3bv[] = "glColor3bv(v) -> None"; 
 static char _doc_glColor3d[] = "glColor3d(red, green, blue) -> None"; 
 static char _doc_glColor3dv[] = "glColor3dv(v) -> None"; 
 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"; 
 static char _doc_glColor3s[] = "glColor3s(red, green, blue) -> None"; 
 static char _doc_glColor3sv[] = "glColor3sv(v) -> None"; 
 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"; 
 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"; 
 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"; 

void _glColorPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_COLOR_ARRAY_POINTER);
	acquire(pointer);
	glColorPointer(size, type, stride, pointer);
}

 static char _doc_glColorPointer[] = "glColorPointer(size, type, stride, pointer) -> None"; 
 static char _doc_glColorPointerub[] = "glColorPointerub(pointer[][]) -> None"; 
 static char _doc_glColorPointerb[] = "glColorPointerb(pointer[][]) -> None"; 
 static char _doc_glColorPointerus[] = "glColorPointerus(pointer[][]) -> None"; 
 static char _doc_glColorPointers[] = "glColorPointers(pointer[][]) -> None"; 
 static char _doc_glColorPointerui[] = "glColorPointerui(pointer[][]) -> None"; 
 static char _doc_glColorPointeri[] = "glColorPointeri(pointer[][]) -> None"; 
 static char _doc_glColorPointerf[] = "glColorPointerf(pointer[][]) -> None"; 
 static char _doc_glColorPointerd[] = "glColorPointerd(pointer[][]) -> 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_glDrawArrays[] = "glDrawArrays(mode, first, count) -> None"; 
 static char _doc_glDrawBuffer[] = "glDrawBuffer(mode) -> None"; 
 static char _doc_glDrawElements[] = "glDrawElements(mode, count, type, indices) -> None"; 
 static char _doc_glDrawElementsub[] = "glDrawElementsub(mode, indices[]) -> None"; 
 static char _doc_glDrawElementsus[] = "glDrawElementsus(mode, indices[]) -> None"; 
 static char _doc_glDrawElementsui[] = "glDrawElementsui(mode, indices[]) -> 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"; 

void _glEdgeFlagPointer(GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_EDGE_FLAG_ARRAY_POINTER);
	acquire(pointer);
	glEdgeFlagPointer(stride, pointer);
}

 static char _doc_glEdgeFlagPointer[] = "glEdgeFlagPointer(stride, pointer) -> None"; 
 static char _doc_glEdgeFlagPointerb[] = "glEdgeFlagPointerb(pointer[]) -> 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"; 
 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_HEIGHT, 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);
	
	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);
	
	data = SetupPixelRead(rank, format, type, dims);
	if (!data) return NULL;
	
	glGetTexImage(target, level, format, type, data);
	
	return _PyObject_FromArray(type, (dims[rank] == 1) ? rank-1 : rank, 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"; 

void _glIndexPointer(GLenum type, GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_INDEX_ARRAY_POINTER);
	acquire(pointer);
	glIndexPointer(type, stride, pointer);
}

 static char _doc_glIndexPointer[] = "glIndexPointer(type, stride, pointer) -> None"; 
 static char _doc_glIndexPointerub[] = "glIndexPointerub(pointer[]) -> None"; 
 static char _doc_glIndexPointerb[] = "glIndexPointerub(pointer[]) -> None"; 
 static char _doc_glIndexPointers[] = "glIndexPointers(pointer[]) -> None"; 
 static char _doc_glIndexPointeri[] = "glIndexPointeri(pointer[]) -> None"; 
 static char _doc_glIndexPointerf[] = "glIndexPointerf(pointer[]) -> None"; 
 static char _doc_glIndexPointerd[] = "glIndexPointerd(pointer[]) -> None"; 
 static char _doc_glInitNames[] = "glInitNames() -> None"; 

#ifndef GL_SUN_triangle_list
#define GL_R1UI_V3F_SUN 0x85C4
#define GL_R1UI_C4UB_V3F_SUN 0x85C5
#define GL_R1UI_C3F_V3F_SUN 0x85C6
#define GL_R1UI_N3F_V3F_SUN 0x85C7
#define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8
#define GL_R1UI_T2F_V3F_SUN 0x85C9
#define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA
#define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB

#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
#endif

#ifndef GL_EXT_index_array_formats
#define GL_IUI_V2F_EXT                    0x81AD
#define GL_IUI_V3F_EXT                    0x81AE
#define GL_IUI_N3F_V2F_EXT                0x81AF
#define GL_IUI_N3F_V3F_EXT                0x81B0
#define GL_T2F_IUI_V2F_EXT                0x81B1
#define GL_T2F_IUI_V3F_EXT                0x81B2
#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
#endif

void _glInterleavedArrays(GLenum format, GLsizei stride, GLvoid *pointer)
{
	GLenum p[POINTER_COUNT];
	
	decrementPointerLock(p[0] = GL_VERTEX_ARRAY_POINTER);
	
	switch (format)
	{
	case GL_C3F_V3F:
	case GL_C4F_N3F_V3F:
	case GL_C4UB_V2F:
	case GL_C4UB_V3F:
	case GL_T2F_C3F_V3F:
	case GL_T2F_C4F_N3F_V3F:
	case GL_T2F_C4UB_V3F:
	case GL_T4F_C4F_N3F_V4F:
	case GL_R1UI_C4UB_V3F_SUN:
	case GL_R1UI_C3F_V3F_SUN:
	case GL_R1UI_C4F_N3F_V3F_SUN:
	case GL_R1UI_T2F_C4F_N3F_V3F_SUN:
		decrementPointerLock(p[1] = GL_COLOR_ARRAY_POINTER);
		break;
	default:
		p[1] = 0;
	}

	switch (format)
	{
	case GL_N3F_V3F:
	case GL_C4F_N3F_V3F:
	case GL_T2F_N3F_V3F:
	case GL_T2F_C4F_N3F_V3F:
	case GL_T4F_C4F_N3F_V4F:
	case GL_R1UI_N3F_V3F_SUN:
	case GL_R1UI_C4F_N3F_V3F_SUN:
	case GL_R1UI_T2F_N3F_V3F_SUN:
	case GL_R1UI_T2F_C4F_N3F_V3F_SUN:
	case GL_IUI_N3F_V2F_EXT:
	case GL_IUI_N3F_V3F_EXT:
	case GL_T2F_IUI_N3F_V2F_EXT:
	case GL_T2F_IUI_N3F_V3F_EXT:
		decrementPointerLock(p[2] = GL_NORMAL_ARRAY_POINTER);
		break;
	default:
		p[2] = 0;
	}

	switch (format)
	{
	case GL_T2F_V3F:
	case GL_T4F_V4F:
	case GL_T2F_C4UB_V3F:
	case GL_T2F_C3F_V3F:
	case GL_T2F_N3F_V3F:
	case GL_T2F_C4F_N3F_V3F:
	case GL_T4F_C4F_N3F_V4F:
	case GL_R1UI_T2F_V3F_SUN:
	case GL_R1UI_T2F_N3F_V3F_SUN:
	case GL_R1UI_T2F_C4F_N3F_V3F_SUN:
	case GL_T2F_IUI_V2F_EXT:
	case GL_T2F_IUI_V3F_EXT:
	case GL_T2F_IUI_N3F_V2F_EXT:
	case GL_T2F_IUI_N3F_V3F_EXT:
		decrementPointerLock(p[3] = GL_TEXTURE_COORD_ARRAY_POINTER);
		break;
	default:
		p[3] = 0;
	}

	switch (format)
	{
	case GL_R1UI_V3F_SUN:
	case GL_R1UI_C4UB_V3F_SUN:
	case GL_R1UI_C3F_V3F_SUN:
	case GL_R1UI_N3F_V3F_SUN:
	case GL_R1UI_C4F_N3F_V3F_SUN:
	case GL_R1UI_T2F_V3F_SUN:
	case GL_R1UI_T2F_N3F_V3F_SUN:
	case GL_R1UI_T2F_C4F_N3F_V3F_SUN:
		decrementPointerLock(p[4] = GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN);
		break;
	default:
		p[4] = 0;
	}

	switch (format)
	{
	case GL_IUI_V2F_EXT:
	case GL_IUI_V3F_EXT:
	case GL_IUI_N3F_V2F_EXT:
	case GL_IUI_N3F_V3F_EXT:
	case GL_T2F_IUI_V2F_EXT:
	case GL_T2F_IUI_V3F_EXT:
	case GL_T2F_IUI_N3F_V2F_EXT:
	case GL_T2F_IUI_N3F_V3F_EXT:
		decrementPointerLock(p[5] = GL_INDEX_ARRAY_POINTER);
		break;
	default:
		p[5] = 0;
	}

	glInterleavedArrays(format, stride, pointer);
	acquireInterleavedPointer(pointer, p);
}

 static char _doc_glInterleavedArrays[] = "glInterleavedArrays(format, stride, pointer) -> None"; 
 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"; 

void _glNormalPointer(GLenum type, GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_NORMAL_ARRAY_POINTER);
	acquire(pointer);
	glNormalPointer(type, stride, pointer);
}

 static char _doc_glNormalPointer[] = "glNormalPointer(size, type, stride, pointer) -> None"; 
 static char _doc_glNormalPointerb[] = "glNormalPointerub(pointer[][3]) -> None"; 
 static char _doc_glNormalPointers[] = "glNormalPointers(pointer[][3]) -> None"; 
 static char _doc_glNormalPointeri[] = "glNormalPointeri(pointer[][3]) -> None"; 
 static char _doc_glNormalPointerf[] = "glNormalPointerf(pointer[][3]) -> None"; 
 static char _doc_glNormalPointerd[] = "glNormalPointerd(pointer[][3]) -> 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_glPolygonOffset[] = "glPolygonOffset(factor, units) -> 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"; 

void _glTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_TEXTURE_COORD_ARRAY_POINTER);
	acquire(pointer);
	glTexCoordPointer(size, type, stride, pointer);
}

 static char _doc_glTexCoordPointer[] = "glTexCoordPointer(size, type, stride, pointer) -> None"; 
 static char _doc_glTexCoordPointerb[] = "glTexCoordPointerub(pointer[][]) -> None"; 
 static char _doc_glTexCoordPointers[] = "glTexCoordPointers(pointer[][]) -> None"; 
 static char _doc_glTexCoordPointeri[] = "glTexCoordPointeri(pointer[][]) -> None"; 
 static char _doc_glTexCoordPointerf[] = "glTexCoordPointerf(pointer[][]) -> None"; 
 static char _doc_glTexCoordPointerd[] = "glTexCoordPointerd(pointer[][]) -> 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"; 

void _glVertexPointer(GLint size, GLenum type, GLsizei stride, GLvoid *pointer)
{
	decrementPointerLock(GL_VERTEX_ARRAY_POINTER);
	acquire(pointer);
	glVertexPointer(size, type, stride, pointer);
}

 static char _doc_glVertexPointer[] = "glVertexPointer(size, type, stride, pointer) -> None"; 
 static char _doc_glVertexPointerb[] = "glVertexPointerub(pointer[][]) -> None"; 
 static char _doc_glVertexPointers[] = "glVertexPointers(pointer[][]) -> None"; 
 static char _doc_glVertexPointeri[] = "glVertexPointeri(pointer[][]) -> None"; 
 static char _doc_glVertexPointerf[] = "glVertexPointerf(pointer[][]) -> None"; 
 static char _doc_glVertexPointerd[] = "glVertexPointerd(pointer[][]) -> 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 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glArrayElement",&arg1)) return NULL;
    {
        glArrayElement(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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


static PyObject *_wrap_glCallLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLenum arg2 ;
    GLuint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glCallLists",&obj0)) return NULL;
    {
        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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor3bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3bv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glColor3d",&arg1,&arg2,&arg3)) return NULL;
    {
        glColor3d(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glColor3f",&arg1,&arg2,&arg3)) return NULL;
    {
        glColor3f(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iii:glColor3i",&arg1,&arg2,&arg3)) return NULL;
    {
        glColor3i(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor3ubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3ubv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, 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;
}


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)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLuint) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLuint) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glColor3ui(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor3uiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3uiv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    arg1 = (GLushort) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLushort) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLushort) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glColor3us(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor3usv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor3usv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedShortArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor4bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4bv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glColor4d",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glColor4d(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glColor4f",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glColor4f(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glColor4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glColor4i",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glColor4i(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glColor4ubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4ubv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedCharArray(obj0, &temp_1, 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;
}


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)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLuint) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLuint) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    arg4 = (GLuint) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        glColor4ui(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor4uiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4uiv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    arg1 = (GLushort) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLushort) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLushort) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    arg4 = (GLushort) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        glColor4us(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColor4usv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLushort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glColor4usv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsUnsignedShortArray(obj0, &temp_1, 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;
}


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


static PyObject *_wrap_glEdgeFlagv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLboolean *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEdgeFlagv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glEvalCoord1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glEvalCoord1d",&arg1)) return NULL;
    {
        glEvalCoord1d(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalCoord1dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glEvalCoord1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glEvalCoord1f",&arg1)) return NULL;
    {
        glEvalCoord1f(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalCoord1fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord1fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glEvalCoord2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dd:glEvalCoord2d",&arg1,&arg2)) return NULL;
    {
        glEvalCoord2d(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalCoord2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord2dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glEvalCoord2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glEvalCoord2f",&arg1,&arg2)) return NULL;
    {
        glEvalCoord2f(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalCoord2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glEvalCoord2fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glEvalPoint1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glEvalPoint1",&arg1)) return NULL;
    {
        glEvalPoint1(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalPoint2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glEvalPoint2",&arg1,&arg2)) return NULL;
    {
        glEvalPoint2(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glIndexd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glIndexd",&arg1)) return NULL;
    {
        glIndexd(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glIndexdv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexdv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glIndexf",&arg1)) return NULL;
    {
        glIndexf(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glIndexfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexfv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glIndexi",&arg1)) return NULL;
    {
        glIndexi(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glIndexiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexiv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexs(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexs",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexsv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexsv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexub",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glIndexubv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexubv",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glMaterialf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOf:glMaterialf",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glMaterialf(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glMaterialfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMaterialfv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glMateriali(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glMateriali",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glMateriali(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glMaterialiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glMaterialiv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glNormal3bv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLbyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3bv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsCharArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glNormal3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glNormal3d",&arg1,&arg2,&arg3)) return NULL;
    {
        glNormal3d(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glNormal3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glNormal3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glNormal3f",&arg1,&arg2,&arg3)) return NULL;
    {
        glNormal3f(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glNormal3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glNormal3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iii:glNormal3i",&arg1,&arg2,&arg3)) return NULL;
    {
        glNormal3i(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glNormal3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glNormal3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glNormal3sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glTexCoord1d",&arg1)) return NULL;
    {
        glTexCoord1d(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord1dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glTexCoord1f",&arg1)) return NULL;
    {
        glTexCoord1f(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord1fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord1i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glTexCoord1i",&arg1)) return NULL;
    {
        glTexCoord1i(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord1iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord1s(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1s",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexCoord1sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord1sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dd:glTexCoord2d",&arg1,&arg2)) return NULL;
    {
        glTexCoord2d(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glTexCoord2f",&arg1,&arg2)) return NULL;
    {
        glTexCoord2f(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glTexCoord2i",&arg1,&arg2)) return NULL;
    {
        glTexCoord2i(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord2iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexCoord2sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord2sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glTexCoord3d",&arg1,&arg2,&arg3)) return NULL;
    {
        glTexCoord3d(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glTexCoord3f",&arg1,&arg2,&arg3)) return NULL;
    {
        glTexCoord3f(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iii:glTexCoord3i",&arg1,&arg2,&arg3)) return NULL;
    {
        glTexCoord3i(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexCoord3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord3sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glTexCoord4d",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glTexCoord4d(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glTexCoord4f",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glTexCoord4f(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glTexCoord4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glTexCoord4i",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glTexCoord4i(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoord4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexCoord4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoord4sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dd:glVertex2d",&arg1,&arg2)) return NULL;
    {
        glVertex2d(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex2dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glVertex2f",&arg1,&arg2)) return NULL;
    {
        glVertex2f(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex2fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glVertex2i",&arg1,&arg2)) return NULL;
    {
        glVertex2i(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex2iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glVertex2sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex2sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glVertex3d",&arg1,&arg2,&arg3)) return NULL;
    {
        glVertex3d(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex3dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glVertex3f",&arg1,&arg2,&arg3)) return NULL;
    {
        glVertex3f(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex3fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iii:glVertex3i",&arg1,&arg2,&arg3)) return NULL;
    {
        glVertex3i(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex3iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glVertex3sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex3sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glVertex4d",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glVertex4d(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex4dv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4dv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsDoubleArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glVertex4f",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glVertex4f(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex4fv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4fv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsFloatArray(obj0, &temp_1, 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;
}


static PyObject *_wrap_glVertex4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glVertex4i",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glVertex4i(arg1,arg2,arg3,arg4);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertex4iv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4iv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsIntArray(obj0, &temp_1, 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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glVertex4sv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glVertex4sv",&obj0)) return NULL;
    {
        arg1 = _PyObject_AsShortArray(obj0, &temp_1, 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;
}


static PyObject *_wrap___has_extension(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)"s:__has_extension",&arg1)) return NULL;
    {
        result = (int)has_extension((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glAccum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glAccum",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glAccum(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glAlphaFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLclampf arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glAlphaFunc",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glAlphaFunc(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glAreTexturesResident(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 ;
    PyObject *result;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glAreTexturesResident",&obj0)) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLuint) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glBindTexture(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glBitmap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    GLfloat arg5 ;
    GLfloat arg6 ;
    GLubyte *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj6  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiffffO:glBitmap",&arg1,&arg2,&arg3,&arg4,&arg5,&arg6,&obj6)) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glBlendFunc(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glClearAccum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glClearAccum",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glClearAccum(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glClearColor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampf arg1 ;
    GLclampf arg2 ;
    GLclampf arg3 ;
    GLclampf arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glClearColor",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glClearColor(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glClearDepth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampd arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glClearDepth",&arg1)) return NULL;
    {
        glClearDepth(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glClearIndex(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glClearIndex",&arg1)) return NULL;
    {
        glClearIndex(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glClearStencil(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glClearStencil",&arg1)) return NULL;
    {
        glClearStencil(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glClipPlane(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glClipPlane",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glColorMaterial(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glColorPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    void *arg4 ;
    PyObject * obj1  = 0 ;
    PyObject * obj3  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iOiO:glColorPointer",&arg1,&obj1,&arg3,&obj3)) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsPointer(obj3);
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLubyte *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_UNSIGNED_BYTE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerub",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsUnsignedCharArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLbyte *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_BYTE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerb",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLushort *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_UNSIGNED_SHORT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerus",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsUnsignedShortArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLshort *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_SHORT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointers",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsShortArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLuint *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_UNSIGNED_INT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerui",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsUnsignedIntArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointeri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLint *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_INT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointeri",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsIntArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLfloat *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_FLOAT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerf",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsFloatArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glColorPointerd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLdouble *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_DOUBLE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glColorPointerd",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsDoubleArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glColorPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glCopyPixels(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    PyObject * obj4  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glCopyPixels",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        glCopyPixels(arg1,arg2,arg3,arg4,arg5);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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 * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiOiiii:glCopyTexImage1D",&obj0,&arg2,&obj2,&arg4,&arg5,&arg6,&arg7)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glCopyTexImage1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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 * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiOiiiii:glCopyTexImage2D",&obj0,&arg2,&obj2,&arg4,&arg5,&arg6,&arg7,&arg8)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glCopyTexImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oiiiii:glCopyTexSubImage1D",&obj0,&arg2,&arg3,&arg4,&arg5,&arg6)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glCopyTexSubImage1D(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oiiiiiii:glCopyTexSubImage2D",&obj0,&arg2,&arg3,&arg4,&arg5,&arg6,&arg7,&arg8)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glCopyTexSubImage2D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glDeleteLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLuint arg1 ;
    GLsizei arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glDeleteLists",&obj0,&arg2)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glDeleteLists(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glDeleteTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glDeleteTextures",&obj0)) return NULL;
    {
        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;
}


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


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


static PyObject *_wrap_glDepthRange(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLclampd arg1 ;
    GLclampd arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dd:glDepthRange",&arg1,&arg2)) return NULL;
    {
        glDepthRange(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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


static PyObject *_wrap_glDrawArrays(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oii:glDrawArrays",&obj0,&arg2,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glDrawArrays(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glDrawElements(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    void *arg4 ;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    PyObject * obj3  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiOO:glDrawElements",&obj0,&arg2,&obj2,&obj3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        int len;
        PyObject* str;
        if (obj3 == Py_None) 
        {
            arg4= NULL; 
        }
        else
        {
            str = PyObject_Str(obj3);
            PyString_AsStringAndSize(str, (char**)&arg4, &len);
            Py_DECREF(str);
        }
    }
    {
        glDrawElements(arg1,arg2,arg3,(void const *)arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glDrawElementsub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLubyte *arg4 ;
    PyObject *temp_4 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
        arg3 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawElementsub",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsUnsignedCharArray(obj1, &temp_4, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glDrawElements(arg1,arg2,arg3,(GLubyte const *)arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg4, temp_4); 
    }
    return resultobj;
}


static PyObject *_wrap_glDrawElementsus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLushort *arg4 ;
    PyObject *temp_4 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
        arg3 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawElementsus",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsUnsignedShortArray(obj1, &temp_4, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glDrawElements(arg1,arg2,arg3,(GLushort const *)arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg4, temp_4); 
    }
    return resultobj;
}


static PyObject *_wrap_glDrawElementsui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLuint *arg4 ;
    PyObject *temp_4 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
        arg3 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawElementsui",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsUnsignedIntArray(obj1, &temp_4, NULL); 
    }
    {
        arg2 = (GLsizei)_PyObject_AsArray_Size(obj1); 
    }
    {
        glDrawElements(arg1,arg2,arg3,(GLuint const *)arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
        _PyObject_AsArray_Cleanup(arg4, temp_4); 
    }
    return resultobj;
}


static PyObject *_wrap_glDrawPixels(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    void *arg5 ;
    PyObject * obj2  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiOOO:glDrawPixels",&arg1,&arg2,&obj2,&obj3,&obj4)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    arg4 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glDrawPixelsub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLubyte *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsub",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsUnsignedCharArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelsb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLbyte *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsb",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsCharArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelsus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLushort *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsus",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsUnsignedShortArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelss(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLshort *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelss",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsShortArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelsui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLuint *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsui",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsUnsignedIntArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelsi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLint *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsi",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsIntArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glDrawPixelsf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLsizei arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    GLfloat *arg5 ;
    PyObject *temp_5 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    {
    }
    {
        arg4 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glDrawPixelsf",&obj0,&obj1)) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg5 = _PyObject_AsFloatArray(obj1, &temp_5, NULL); 
    }
    {
        arg1 = (GLsizei)_PyObject_Dimension(obj1, 1); 
    }
    {
        arg2 = (GLsizei)_PyObject_Dimension(obj1, 0); 
    }
    {
        _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;
}


static PyObject *_wrap_glEdgeFlagPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    void *arg2 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iO:glEdgeFlagPointer",&arg1,&obj1)) return NULL;
    {
        arg2 = _PyObject_AsPointer(obj1);
    }
    {
        _glEdgeFlagPointer(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glEdgeFlagPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLbyte *arg2 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glEdgeFlagPointerb",&obj0)) return NULL;
    {
        arg2 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        _glEdgeFlagPointer(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


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


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


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


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


static PyObject *_wrap_glEvalMesh1(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oii:glEvalMesh1",&obj0,&arg2,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glEvalMesh1(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glEvalMesh2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oiiii:glEvalMesh2",&obj0,&arg2,&arg3,&arg4,&arg5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glEvalMesh2(arg1,arg2,arg3,arg4,arg5);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glFeedbackBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLenum arg2 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iO:glFeedbackBuffer",&arg1,&obj1)) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        _glFeedbackBuffer(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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


static PyObject *_wrap_glFogf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glFogf",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glFogf(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glFogfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogfv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg2 = _PyObject_AsFloatArray(obj1, &temp_2, 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;
}


static PyObject *_wrap_glFogi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glFogi",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glFogi(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glFogiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glFogiv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg2 = _PyObject_AsIntArray(obj1, &temp_2, 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;
}


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


static PyObject *_wrap_glFrustum(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddddd:glFrustum",&arg1,&arg2,&arg3,&arg4,&arg5,&arg6)) return NULL;
    {
        glFrustum(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glGenLists(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint result;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glGenLists",&arg1)) return NULL;
    {
        result = (GLuint)glGenLists(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glGenTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    PyObject *result;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glGenTextures",&arg1)) return NULL;
    {
        result = (PyObject *)_glGenTextures(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetMapdv(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetMapdv(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetMapiv(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetPixelMapfv(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetPixelMapuiv(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetPixelMapusv(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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


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


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (GLubyte *)glGetString(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        if (result) 
        {
            resultobj= PyString_FromString(result); 
        }
        else 
        {
            Py_INCREF(resultobj = Py_None);
        }
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glGetTexImage(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    PyObject * obj3  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiOO:glGetTexImage",&obj0,&arg2,&obj2,&obj3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    arg4 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImageub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImageub",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImageb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImageb",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImageus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImageus",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImages(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImages",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImageui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImageui",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImagei(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImagei",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImagef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImagef",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glGetTexImaged(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLenum arg3 ;
    GLenum arg4 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    {
        arg4 = GL_DOUBLE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexImaged",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glGetTexImage(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj2  = 0 ;
    
    {
        int i; 	arg4 = temp_4; 	for (i = 0; i < 4; i++) arg4[i] = -FLT_MAX; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexLevelParameterfv",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 * obj2  = 0 ;
    
    {
        int i; 	arg4 = temp_4; 	for (i = 0; i < 4; i++) arg4[i] = INT_MIN; 
    }
    if(!PyArg_ParseTuple(args,(char *)"OiO:glGetTexLevelParameteriv",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glHint(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glIndexPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    void *arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiO:glIndexPointer",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsPointer(obj2);
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointerub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLubyte *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_UNSIGNED_BYTE;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointerub",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsUnsignedCharArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLbyte *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_BYTE;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointerb",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLshort *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_SHORT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointers",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsShortArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointeri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLint *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_INT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointeri",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointerf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLfloat *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_FLOAT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointerf",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glIndexPointerd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLdouble *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_DOUBLE;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glIndexPointerd",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsDoubleArray(obj0, NULL, NULL); 
    }
    {
        _glIndexPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


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


static PyObject *_wrap_glInterleavedArrays(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    void *arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiO:glInterleavedArrays",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsPointer(obj2);
    }
    {
        _glInterleavedArrays(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (GLboolean)glIsEnabled(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


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)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (GLboolean)glIsList(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


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)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (GLboolean)glIsTexture(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glLightModelf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glLightModelf",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glLightModelf(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glLightModelfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModelfv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg2 = _PyObject_AsFloatArray(obj1, &temp_2, 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;
}


static PyObject *_wrap_glLightModeli(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glLightModeli",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glLightModeli(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glLightModeliv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint *arg2 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glLightModeliv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg2 = _PyObject_AsIntArray(obj1, &temp_2, 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;
}


static PyObject *_wrap_glLightf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOf:glLightf",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glLightf(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glLightfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLightfv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glLighti(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glLighti",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glLighti(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glLightiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glLightiv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glLineStipple(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLushort arg2 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iO:glLineStipple",&arg1,&obj1)) return NULL;
    arg2 = (GLushort) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glLineStipple(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glLineWidth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glLineWidth",&arg1)) return NULL;
    {
        glLineWidth(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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


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


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


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


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


static PyObject *_wrap_glMap1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLdouble *arg6 ;
    PyObject *temp_6 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    
    {
    }
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OddO:glMap1d",&obj0,&arg2,&arg3,&obj3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg6 = _PyObject_AsDoubleArray(obj3, &temp_6, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        arg5 = (GLint)_PyObject_Dimension(obj0, 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;
}


static PyObject *_wrap_glMap1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLint arg4 ;
    GLint arg5 ;
    GLfloat *arg6 ;
    PyObject *temp_6 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    
    {
    }
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OffO:glMap1f",&obj0,&arg2,&arg3,&obj3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg6 = _PyObject_AsFloatArray(obj3, &temp_6, NULL); 
    }
    {
        arg4 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        arg5 = (GLint)_PyObject_Dimension(obj0, 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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OddddO:glMap2d",&obj0,&arg2,&arg3,&arg5,&arg6,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OffffO:glMap2f",&obj0,&arg2,&arg3,&arg5,&arg6,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glMapGrid1d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"idd:glMapGrid1d",&arg1,&arg2,&arg3)) return NULL;
    {
        glMapGrid1d(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glMapGrid1f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iff:glMapGrid1f",&arg1,&arg2,&arg3)) return NULL;
    {
        glMapGrid1f(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glMapGrid2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLint arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iddidd:glMapGrid2d",&arg1,&arg2,&arg3,&arg4,&arg5,&arg6)) return NULL;
    {
        glMapGrid2d(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glMapGrid2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLint arg4 ;
    GLfloat arg5 ;
    GLfloat arg6 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iffiff:glMapGrid2f",&arg1,&arg2,&arg3,&arg4,&arg5,&arg6)) return NULL;
    {
        glMapGrid2f(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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


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


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)) return NULL;
    arg1 = (GLuint) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glNewList(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glNormalPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    void *arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiO:glNormalPointer",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsPointer(obj2);
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glNormalPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLbyte *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_BYTE;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glNormalPointerb",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glNormalPointers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLshort *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_SHORT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glNormalPointers",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsShortArray(obj0, NULL, NULL); 
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glNormalPointeri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLint *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_INT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glNormalPointeri",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj0, NULL, NULL); 
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glNormalPointerf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLfloat *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_FLOAT;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glNormalPointerf",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj0, NULL, NULL); 
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glNormalPointerd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLdouble *arg3 ;
    PyObject * obj0  = 0 ;
    
    {
        arg1 = GL_DOUBLE;
    }
    {
        arg2 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glNormalPointerd",&obj0)) return NULL;
    {
        arg3 = _PyObject_AsDoubleArray(obj0, NULL, NULL); 
    }
    {
        _glNormalPointer(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glOrtho(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    GLdouble arg5 ;
    GLdouble arg6 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddddd:glOrtho",&arg1,&arg2,&arg3,&arg4,&arg5,&arg6)) return NULL;
    {
        glOrtho(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPassThrough(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glPassThrough",&arg1)) return NULL;
    {
        glPassThrough(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPixelMapfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapfv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glPixelMapuiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLuint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapuiv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glPixelMapusv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLsizei arg2 ;
    GLushort *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPixelMapusv",&obj0,&obj1)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glPixelStoref(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glPixelStoref",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glPixelStoref(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPixelStorei(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glPixelStorei",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glPixelStorei(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPixelTransferf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLfloat arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Of:glPixelTransferf",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glPixelTransferf(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPixelTransferi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glPixelTransferi",&obj0,&arg2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glPixelTransferi(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPixelZoom(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glPixelZoom",&arg1,&arg2)) return NULL;
    {
        glPixelZoom(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPointSize(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"f:glPointSize",&arg1)) return NULL;
    {
        glPointSize(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glPolygonMode(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPolygonOffset(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glPolygonOffset",&arg1,&arg2)) return NULL;
    {
        glPolygonOffset(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glPolygonStipple(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPolygonStipple",&obj0)) return NULL;
    {
        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;
}


static PyObject *_wrap_glPolygonStippleub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLubyte *arg1 ;
    PyObject *temp_1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glPolygonStippleub",&obj0)) return NULL;
    {
        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;
}


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


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


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


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


static PyObject *_wrap_glPrioritizeTextures(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    GLuint *arg2 ;
    GLclampf *arg3 ;
    PyObject *temp_2 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    {
    }
    if(!PyArg_ParseTuple(args,(char *)"OO:glPrioritizeTextures",&obj0,&obj1)) return NULL;
    {
        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;
}


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


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


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


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


static PyObject *_wrap_glRasterPos2d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dd:glRasterPos2d",&arg1,&arg2)) return NULL;
    {
        glRasterPos2d(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos2f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ff:glRasterPos2f",&arg1,&arg2)) return NULL;
    {
        glRasterPos2f(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos2i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glRasterPos2i",&arg1,&arg2)) return NULL;
    {
        glRasterPos2i(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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)) return NULL;
    {
        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;
}


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


static PyObject *_wrap_glRasterPos3d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glRasterPos3d",&arg1,&arg2,&arg3)) return NULL;
    {
        glRasterPos3d(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos3f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glRasterPos3f",&arg1,&arg2,&arg3)) return NULL;
    {
        glRasterPos3f(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos3i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iii:glRasterPos3i",&arg1,&arg2,&arg3)) return NULL;
    {
        glRasterPos3i(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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)) return NULL;
    {
        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;
}


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


static PyObject *_wrap_glRasterPos4d(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glRasterPos4d",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRasterPos4d(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos4f(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glRasterPos4f",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRasterPos4f(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glRasterPos4i(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glRasterPos4i",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRasterPos4i(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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)) return NULL;
    {
        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;
}


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


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


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 * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiiiOO:glReadPixels",&arg1,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj5);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsub",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsb",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsus",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelss",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsui",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsi",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsf",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


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 * obj4  = 0 ;
    
    {
        arg6 = GL_DOUBLE;
    }
    if(!PyArg_ParseTuple(args,(char *)"iiiiO:glReadPixelsd",&arg1,&arg2,&arg3,&arg4,&obj4)) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)__glReadPixels(arg1,arg2,arg3,arg4,arg5,arg6);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glRectd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glRectd",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRectd(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glRectdv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble *arg1 ;
    GLdouble *arg2 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectdv",&obj0,&obj1)) return NULL;
    {
        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;
}


static PyObject *_wrap_glRectf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glRectf",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRectf(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glRectfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat *arg1 ;
    GLfloat *arg2 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectfv",&obj0,&obj1)) return NULL;
    {
        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;
}


static PyObject *_wrap_glRecti(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glRecti",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRecti(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glRectiv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint *arg1 ;
    GLint *arg2 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectiv",&obj0,&obj1)) return NULL;
    {
        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;
}


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)) return NULL;
    {
        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;
}


static PyObject *_wrap_glRectsv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLshort *arg1 ;
    GLshort *arg2 ;
    PyObject *temp_1 ;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glRectsv",&obj0,&obj1)) return NULL;
    {
        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;
}


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (PyObject *)_glRenderMode(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glRotated(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    GLdouble arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dddd:glRotated",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRotated(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glRotatef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ffff:glRotatef",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glRotatef(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glScaled(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glScaled",&arg1,&arg2,&arg3)) return NULL;
    {
        glScaled(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glScalef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glScalef",&arg1,&arg2,&arg3)) return NULL;
    {
        glScalef(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glScissor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glScissor",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glScissor(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glSelectBuffer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLsizei arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glSelectBuffer",&arg1)) return NULL;
    {
        _glSelectBuffer(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


static PyObject *_wrap_glStencilFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLuint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiO:glStencilFunc",&obj0,&arg2,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLuint) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glStencilFunc(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


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


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)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    arg3 = (GLenum) PyInt_AsLong(obj2);
    if (PyErr_Occurred()) return NULL;
    {
        glStencilOp(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    void *arg4 ;
    PyObject * obj1  = 0 ;
    PyObject * obj3  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iOiO:glTexCoordPointer",&arg1,&obj1,&arg3,&obj3)) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsPointer(obj3);
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLbyte *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_BYTE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoordPointerb",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLshort *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_SHORT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoordPointers",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsShortArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointeri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLint *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_INT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoordPointeri",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsIntArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointerf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLfloat *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_FLOAT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoordPointerf",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsFloatArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexCoordPointerd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLdouble *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_DOUBLE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glTexCoordPointerd",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsDoubleArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glTexCoordPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glTexEnvf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOf:glTexEnvf",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexEnvf(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexEnvfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnvfv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexEnvi(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glTexEnvi",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexEnvi(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexEnviv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexEnviv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexGend(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLdouble arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOd:glTexGend",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexGend(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexGendv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLdouble *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGendv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsDoubleArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexGenf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOf:glTexGenf",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexGenf(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexGenfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGenfv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexGeni(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glTexGeni",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexGeni(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexGeniv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexGeniv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, 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;
}


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 ;
    PyObject * obj0  = 0 ;
    PyObject * obj5  = 0 ;
    PyObject * obj6  = 0 ;
    PyObject * obj7  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiiiiOOO:glTexImage1D",&obj0,&arg2,&arg3,&arg4,&arg5,&obj5,&obj6,&obj7)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj5);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj6);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Dub",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Db",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Dus",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Ds",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Dui",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Di",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_8 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
        arg7 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage1Df",&obj0,&arg2,&arg3,&arg5,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject * obj0  = 0 ;
    PyObject * obj6  = 0 ;
    PyObject * obj7  = 0 ;
    PyObject * obj8  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiiiiiOOO:glTexImage2D",&obj0,&arg2,&arg3,&arg4,&arg5,&arg6,&obj6,&obj7,&obj8)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj6);
    if (PyErr_Occurred()) return NULL;
    arg8 = (GLenum) PyInt_AsLong(obj7);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Dub",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Db",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Dus",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Ds",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Dui",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Di",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexImage2Df",&obj0,&arg2,&arg3,&arg6,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexParameterf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOf:glTexParameterf",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexParameterf(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexParameterfv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLfloat *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameterfv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsFloatArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexParameteri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glTexParameteri",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        glTexParameteri(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTexParameteriv(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLenum arg2 ;
    GLint *arg3 ;
    PyObject *temp_3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    PyObject * obj2  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:glTexParameteriv",&obj0,&obj1,&obj2)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg3 = _PyObject_AsIntArray(obj2, &temp_3, 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;
}


static PyObject *_wrap_glTexSubImage1D(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    void *arg7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    PyObject * obj6  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiiiOOO:glTexSubImage1D",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5,&obj6)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    arg6 = (GLenum) PyInt_AsLong(obj5);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Dub(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLubyte *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Dub",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Db(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLbyte *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Db",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Dus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLushort *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Dus",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Ds(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLshort *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Ds",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Dui(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLuint *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Dui",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Di(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLint *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Di",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTexSubImage1Df(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    GLsizei arg4 ;
    GLenum arg5 ;
    GLenum arg6 ;
    GLfloat *arg7 ;
    PyObject *temp_7 ;
    PyObject * obj0  = 0 ;
    PyObject * obj3  = 0 ;
    PyObject * obj4  = 0 ;
    
    {
    }
    {
        arg6 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiOO:glTexSubImage1Df",&obj0,&arg2,&arg3,&obj3,&obj4)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg5 = (GLenum) PyInt_AsLong(obj3);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject * obj0  = 0 ;
    PyObject * obj6  = 0 ;
    PyObject * obj7  = 0 ;
    PyObject * obj8  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OiiiiiOOO:glTexSubImage2D",&obj0,&arg2,&arg3,&arg4,&arg5,&arg6,&obj6,&obj7,&obj8)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj6);
    if (PyErr_Occurred()) return NULL;
    arg8 = (GLenum) PyInt_AsLong(obj7);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Dub",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_BYTE;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Db",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Dus",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_SHORT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Ds",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_UNSIGNED_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Dui",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_INT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Di",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


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 ;
    PyObject *temp_9 ;
    PyObject * obj0  = 0 ;
    PyObject * obj4  = 0 ;
    PyObject * obj5  = 0 ;
    
    {
    }
    {
    }
    {
        arg8 = GL_FLOAT;
    }
    if(!PyArg_ParseTuple(args,(char *)"OiiiOO:glTexSubImage2Df",&obj0,&arg2,&arg3,&arg4,&obj4,&obj5)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    arg7 = (GLenum) PyInt_AsLong(obj4);
    if (PyErr_Occurred()) return NULL;
    {
        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;
}


static PyObject *_wrap_glTranslated(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLdouble arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddd:glTranslated",&arg1,&arg2,&arg3)) return NULL;
    {
        glTranslated(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glTranslatef(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLfloat arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"fff:glTranslatef",&arg1,&arg2,&arg3)) return NULL;
    {
        glTranslatef(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glVertexPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    void *arg4 ;
    PyObject * obj1  = 0 ;
    PyObject * obj3  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iOiO:glVertexPointer",&arg1,&obj1,&arg3,&obj3)) return NULL;
    arg2 = (GLenum) PyInt_AsLong(obj1);
    if (PyErr_Occurred()) return NULL;
    {
        arg4 = _PyObject_AsPointer(obj3);
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glVertexPointerb(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLbyte *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_BYTE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glVertexPointerb",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsCharArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glVertexPointers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLshort *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_SHORT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glVertexPointers",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsShortArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glVertexPointeri(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLint *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_INT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glVertexPointeri",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsIntArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glVertexPointerf(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLfloat *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_FLOAT;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glVertexPointerf",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsFloatArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glVertexPointerd(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLenum arg2 ;
    GLsizei arg3 ;
    GLdouble *arg4 ;
    PyObject * obj0  = 0 ;
    
    {
    }
    {
        arg2 = GL_DOUBLE;
    }
    {
        arg3 = 0;
    }
    if(!PyArg_ParseTuple(args,(char *)"O:glVertexPointerd",&obj0)) return NULL;
    {
        arg4 = _PyObject_AsDoubleArray(obj0, NULL, NULL); 
    }
    {
        arg1 = (GLint)_PyObject_Dimension(obj0, 1); 
    }
    {
        _glVertexPointer(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    {
    }
    return resultobj;
}


static PyObject *_wrap_glViewport(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLint arg1 ;
    GLint arg2 ;
    GLsizei arg3 ;
    GLsizei arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glViewport",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glViewport(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"glArrayElement", _wrap_glArrayElement, METH_VARARGS , _doc_glArrayElement},
	 { (char *)"glBegin", _wrap_glBegin, METH_VARARGS , _doc_glBegin},
	 { (char *)"glCallList", _wrap_glCallList, METH_VARARGS , _doc_glCallList},
	 { (char *)"glCallLists", _wrap_glCallLists, METH_VARARGS , _doc_glCallLists},
	 { (char *)"glColor3b", _wrap_glColor3b, METH_VARARGS , _doc_glColor3b},
	 { (char *)"glColor3bv", _wrap_glColor3bv, METH_VARARGS , _doc_glColor3bv},
	 { (char *)"glColor3d", _wrap_glColor3d, METH_VARARGS , _doc_glColor3d},
	 { (char *)"glColor3dv", _wrap_glColor3dv, METH_VARARGS , _doc_glColor3dv},
	 { (char *)"glColor3f", _wrap_glColor3f, METH_VARARGS , _doc_glColor3f},
	 { (char *)"glColor3fv", _wrap_glColor3fv, METH_VARARGS , _doc_glColor3fv},
	 { (char *)"glColor3i", _wrap_glColor3i, METH_VARARGS , _doc_glColor3i},
	 { (char *)"glColor3iv", _wrap_glColor3iv, METH_VARARGS , _doc_glColor3iv},
	 { (char *)"glColor3s", _wrap_glColor3s, METH_VARARGS , _doc_glColor3s},
	 { (char *)"glColor3sv", _wrap_glColor3sv, METH_VARARGS , _doc_glColor3sv},
	 { (char *)"glColor3ub", _wrap_glColor3ub, METH_VARARGS , _doc_glColor3ub},
	 { (char *)"glColor3ubv", _wrap_glColor3ubv, METH_VARARGS , _doc_glColor3ubv},
	 { (char *)"glColor3ui", _wrap_glColor3ui, METH_VARARGS , _doc_glColor3ui},
	 { (char *)"glColor3uiv", _wrap_glColor3uiv, METH_VARARGS , _doc_glColor3uiv},
	 { (char *)"glColor3us", _wrap_glColor3us, METH_VARARGS , _doc_glColor3us},
	 { (char *)"glColor3usv", _wrap_glColor3usv, METH_VARARGS , _doc_glColor3usv},
	 { (char *)"glColor4b", _wrap_glColor4b, METH_VARARGS , _doc_glColor4b},
	 { (char *)"glColor4bv", _wrap_glColor4bv, METH_VARARGS , _doc_glColor4bv},
	 { (char *)"glColor4d", _wrap_glColor4d, METH_VARARGS , _doc_glColor4d},
	 { (char *)"glColor4dv", _wrap_glColor4dv, METH_VARARGS , _doc_glColor4dv},
	 { (char *)"glColor4f", _wrap_glColor4f, METH_VARARGS , _doc_glColor4f},
	 { (char *)"glColor4fv", _wrap_glColor4fv, METH_VARARGS , _doc_glColor4fv},
	 { (char *)"glColor4i", _wrap_glColor4i, METH_VARARGS , _doc_glColor4i},
	 { (char *)"glColor4iv", _wrap_glColor4iv, METH_VARARGS , _doc_glColor4iv},
	 { (char *)"glColor4s", _wrap_glColor4s, METH_VARARGS , _doc_glColor4s},
	 { (char *)"glColor4sv", _wrap_glColor4sv, METH_VARARGS , _doc_glColor4sv},
	 { (char *)"glColor4ub", _wrap_glColor4ub, METH_VARARGS , _doc_glColor4ub},
	 { (char *)"glColor4ubv", _wrap_glColor4ubv, METH_VARARGS , _doc_glColor4ubv},
	 { (char *)"glColor4ui", _wrap_glColor4ui, METH_VARARGS , _doc_glColor4ui},
	 { (char *)"glColor4uiv", _wrap_glColor4uiv, METH_VARARGS , _doc_glColor4uiv},
	 { (char *)"glColor4us", _wrap_glColor4us, METH_VARARGS , _doc_glColor4us},
	 { (char *)"glColor4usv", _wrap_glColor4usv, METH_VARARGS , _doc_glColor4usv},
	 { (char *)"glEdgeFlag", _wrap_glEdgeFlag, METH_VARARGS , _doc_glEdgeFlag},
	 { (char *)"glEdgeFlagv", _wrap_glEdgeFlagv, METH_VARARGS , _doc_glEdgeFlagv},
	 { (char *)"glEvalCoord1d", _wrap_glEvalCoord1d, METH_VARARGS , _doc_glEvalCoord1d},
	 { (char *)"glEvalCoord1dv", _wrap_glEvalCoord1dv, METH_VARARGS , _doc_glEvalCoord1dv},
	 { (char *)"glEvalCoord1f", _wrap_glEvalCoord1f, METH_VARARGS , _doc_glEvalCoord1f},
	 { (char *)"glEvalCoord1fv", _wrap_glEvalCoord1fv, METH_VARARGS , _doc_glEvalCoord1fv},
	 { (char *)"glEvalCoord2d", _wrap_glEvalCoord2d, METH_VARARGS , _doc_glEvalCoord2d},
	 { (char *)"glEvalCoord2dv", _wrap_glEvalCoord2dv, METH_VARARGS , _doc_glEvalCoord2dv},
	 { (char *)"glEvalCoord2f", _wrap_glEvalCoord2f, METH_VARARGS , _doc_glEvalCoord2f},
	 { (char *)"glEvalCoord2fv", _wrap_glEvalCoord2fv, METH_VARARGS , _doc_glEvalCoord2fv},
	 { (char *)"glEvalPoint1", _wrap_glEvalPoint1, METH_VARARGS , _doc_glEvalPoint1},
	 { (char *)"glEvalPoint2", _wrap_glEvalPoint2, METH_VARARGS , _doc_glEvalPoint2},
	 { (char *)"glIndexd", _wrap_glIndexd, METH_VARARGS , _doc_glIndexd},
	 { (char *)"glIndexdv", _wrap_glIndexdv, METH_VARARGS , _doc_glIndexdv},
	 { (char *)"glIndexf", _wrap_glIndexf, METH_VARARGS , _doc_glIndexf},
	 { (char *)"glIndexfv", _wrap_glIndexfv, METH_VARARGS , _doc_glIndexfv},
	 { (char *)"glIndexi", _wrap_glIndexi, METH_VARARGS , _doc_glIndexi},
	 { (char *)"glIndexiv", _wrap_glIndexiv, METH_VARARGS , _doc_glIndexiv},
	 { (char *)"glIndexs", _wrap_glIndexs, METH_VARARGS , _doc_glIndexs},
	 { (char *)"glIndexsv", _wrap_glIndexsv, METH_VARARGS , _doc_glIndexsv},
	 { (char *)"glIndexub", _wrap_glIndexub, METH_VARARGS , _doc_glIndexub},
	 { (char *)"glIndexubv", _wrap_glIndexubv, METH_VARARGS , _doc_glIndexubv},
	 { (char *)"glMaterialf", _wrap_glMaterialf, METH_VARARGS , _doc_glMaterialf},
	 { (char *)"glMaterialfv", _wrap_glMaterialfv, METH_VARARGS , _doc_glMaterialfv},
	 { (char *)"glMateriali", _wrap_glMateriali, METH_VARARGS , _doc_glMateriali},
	 { (char *)"glMaterialiv", _wrap_glMaterialiv, METH_VARARGS , _doc_glMaterialiv},
	 { (char *)"glNormal3b", _wrap_glNormal3b, METH_VARARGS , _doc_glNormal3b},
	 { (char *)"glNormal3bv", _wrap_glNormal3bv, METH_VARARGS , _doc_glNormal3bv},
	 { (char *)"glNormal3d", _wrap_glNormal3d, METH_VARARGS , _doc_glNormal3d},
	 { (char *)"glNormal3dv", _wrap_glNormal3dv, METH_VARARGS , _doc_glNormal3dv},
	 { (char *)"glNormal3f", _wrap_glNormal3f, METH_VARARGS , _doc_glNormal3f},
	 { (char *)"glNormal3fv", _wrap_glNormal3fv, METH_VARARGS , _doc_glNormal3fv},
	 { (char *)"glNormal3i", _wrap_glNormal3i, METH_VARARGS , _doc_glNormal3i},
	 { (char *)"glNormal3iv", _wrap_glNormal3iv, METH_VARARGS , _doc_glNormal3iv},
	 { (char *)"glNormal3s", _wrap_glNormal3s, METH_VARARGS , _doc_glNormal3s},
	 { (char *)"glNormal3sv", _wrap_glNormal3sv, METH_VARARGS , _doc_glNormal3sv},
	 { (char *)"glTexCoord1d", _wrap_glTexCoord1d, METH_VARARGS , _doc_glTexCoord1d},
	 { (char *)"glTexCoord1dv", _wrap_glTexCoord1dv, METH_VARARGS , _doc_glTexCoord1dv},
	 { (char *)"glTexCoord1f", _wrap_glTexCoord1f, METH_VARARGS , _doc_glTexCoord1f},
	 { (char *)"glTexCoord1fv", _wrap_glTexCoord1fv, METH_VARARGS , _doc_glTexCoord1fv},
	 { (char *)"glTexCoord1i", _wrap_glTexCoord1i, METH_VARARGS , _doc_glTexCoord1i},
	 { (char *)"glTexCoord1iv", _wrap_glTexCoord1iv, METH_VARARGS , _doc_glTexCoord1iv},
	 { (char *)"glTexCoord1s", _wrap_glTexCoord1s, METH_VARARGS , _doc_glTexCoord1s},
	 { (char *)"glTexCoord1sv", _wrap_glTexCoord1sv, METH_VARARGS , _doc_glTexCoord1sv},
	 { (char *)"glTexCoord2d", _wrap_glTexCoord2d, METH_VARARGS , _doc_glTexCoord2d},
	 { (char *)"glTexCoord2dv", _wrap_glTexCoord2dv, METH_VARARGS , _doc_glTexCoord2dv},
	 { (char *)"glTexCoord2f", _wrap_glTexCoord2f, METH_VARARGS , _doc_glTexCoord2f},
	 { (char *)"glTexCoord2fv", _wrap_glTexCoord2fv, METH_VARARGS , _doc_glTexCoord2fv},
	 { (char *)"glTexCoord2i", _wrap_glTexCoord2i, METH_VARARGS , _doc_glTexCoord2i},
	 { (char *)"glTexCoord2iv", _wrap_glTexCoord2iv, METH_VARARGS , _doc_glTexCoord2iv},
	 { (char *)"glTexCoord2s", _wrap_glTexCoord2s, METH_VARARGS , _doc_glTexCoord2s},
	 { (char *)"glTexCoord2sv", _wrap_glTexCoord2sv, METH_VARARGS , _doc_glTexCoord2sv},
	 { (char *)"glTexCoord3d", _wrap_glTexCoord3d, METH_VARARGS , _doc_glTexCoord3d},
	 { (char *)"glTexCoord3dv", _wrap_glTexCoord3dv, METH_VARARGS , _doc_glTexCoord3dv},
	 { (char *)"glTexCoord3f", _wrap_glTexCoord3f, METH_VARARGS , _doc_glTexCoord3f},
	 { (char *)"glTexCoord3fv", _wrap_glTexCoord3fv, METH_VARARGS , _doc_glTexCoord3fv},
	 { (char *)"glTexCoord3i", _wrap_glTexCoord3i, METH_VARARGS , _doc_glTexCoord3i},
	 { (char *)"glTexCoord3iv", _wrap_glTexCoord3iv, METH_VARARGS , _doc_glTexCoord3iv},
	 { (char *)"glTexCoord3s", _wrap_glTexCoord3s, METH_VARARGS , _doc_glTexCoord3s},
	 { (char *)"glTexCoord3sv", _wrap_glTexCoord3sv, METH_VARARGS , _doc_glTexCoord3sv},
	 { (char *)"glTexCoord4d", _wrap_glTexCoord4d, METH_VARARGS , _doc_glTexCoord4d},
	 { (char *)"glTexCoord4dv", _wrap_glTexCoord4dv, METH_VARARGS , _doc_glTexCoord4dv},
	 { (char *)"glTexCoord4f", _wrap_glTexCoord4f, METH_VARARGS , _doc_glTexCoord4f},
	 { (char *)"glTexCoord4fv", _wrap_glTexCoord4fv, METH_VARARGS , _doc_glTexCoord4fv},
	 { (char *)"glTexCoord4i", _wrap_glTexCoord4i, METH_VARARGS , _doc_glTexCoord4i},
	 { (char *)"glTexCoord4iv", _wrap_glTexCoord4iv, METH_VARARGS , _doc_glTexCoord4iv},
	 { (char *)"glTexCoord4s", _wrap_glTexCoord4s, METH_VARARGS , _doc_glTexCoord4s},
	 { (char *)"glTexCoord4sv", _wrap_glTexCoord4sv, METH_VARARGS , _doc_glTexCoord4sv},
	 { (char *)"glVertex2d", _wrap_glVertex2d, METH_VARARGS , _doc_glVertex2d},
	 { (char *)"glVertex2dv", _wrap_glVertex2dv, METH_VARARGS , _doc_glVertex2dv},
	 { (char *)"glVertex2f", _wrap_glVertex2f, METH_VARARGS , _doc_glVertex2f},
	 { (char *)"glVertex2fv", _wrap_glVertex2fv, METH_VARARGS , _doc_glVertex2fv},
	 { (char *)"glVertex2i", _wrap_glVertex2i, METH_VARARGS , _doc_glVertex2i},
	 { (char *)"glVertex2iv", _wrap_glVertex2iv, METH_VARARGS , _doc_glVertex2iv},
	 { (char *)"glVertex2s", _wrap_glVertex2s, METH_VARARGS , _doc_glVertex2s},
	 { (char *)"glVertex2sv", _wrap_glVertex2sv, METH_VARARGS , _doc_glVertex2sv},
	 { (char *)"glVertex3d", _wrap_glVertex3d, METH_VARARGS , _doc_glVertex3d},
	 { (char *)"glVertex3dv", _wrap_glVertex3dv, METH_VARARGS , _doc_glVertex3dv},
	 { (char *)"glVertex3f", _wrap_glVertex3f, METH_VARARGS , _doc_glVertex3f},
	 { (char *)"glVertex3fv", _wrap_glVertex3fv, METH_VARARGS , _doc_glVertex3fv},
	 { (char *)"glVertex3i", _wrap_glVertex3i, METH_VARARGS , _doc_glVertex3i},
	 { (char *)"glVertex3iv", _wrap_glVertex3iv, METH_VARARGS , _doc_glVertex3iv},
	 { (char *)"glVertex3s", _wrap_glVertex3s, METH_VARARGS , _doc_glVertex3s},
	 { (char *)"glVertex3sv", _wrap_glVertex3sv, METH_VARARGS , _doc_glVertex3sv},
	 { (char *)"glVertex4d", _wrap_glVertex4d, METH_VARARGS , _doc_glVertex4d},
	 { (char *)"glVertex4dv", _wrap_glVertex4dv, METH_VARARGS , _doc_glVertex4dv},
	 { (char *)"glVertex4f", _wrap_glVertex4f, METH_VARARGS , _doc_glVertex4f},
	 { (char *)"glVertex4fv", _wrap_glVertex4fv, METH_VARARGS , _doc_glVertex4fv},
	 { (char *)"glVertex4i", _wrap_glVertex4i, METH_VARARGS , _doc_glVertex4i},
	 { (char *)"glVertex4iv", _wrap_glVertex4iv, METH_VARARGS , _doc_glVertex4iv},
	 { (char *)"glVertex4s", _wrap_glVertex4s, METH_VARARGS , _doc_glVertex4s},
	 { (char *)"glVertex4sv", _wrap_glVertex4sv, METH_VARARGS , _doc_glVertex4sv},
	 { (char *)"__has_extension", _wrap___has_extension, METH_VARARGS , _doc___has_extension},
	 { (char *)"glAccum", _wrap_glAccum, METH_VARARGS , _doc_glAccum},
	 { (char *)"glAlphaFunc", _wrap_glAlphaFunc, METH_VARARGS , _doc_glAlphaFunc},
	 { (char *)"glAreTexturesResident", _wrap_glAreTexturesResident, METH_VARARGS , _doc_glAreTexturesResident},
	 { (char *)"glBindTexture", _wrap_glBindTexture, METH_VARARGS , _doc_glBindTexture},
	 { (char *)"glBitmap", _wrap_glBitmap, METH_VARARGS , _doc_glBitmap},
	 { (char *)"glBlendFunc", _wrap_glBlendFunc, METH_VARARGS , _doc_glBlendFunc},
	 { (char *)"glClear", _wrap_glClear, METH_VARARGS , _doc_glClear},
	 { (char *)"glClearAccum", _wrap_glClearAccum, METH_VARARGS , _doc_glClearAccum},
	 { (char *)"glClearColor", _wrap_glClearColor, METH_VARARGS , _doc_glClearColor},
	 { (char *)"glClearDepth", _wrap_glClearDepth, METH_VARARGS , _doc_glClearDepth},
	 { (char *)"glClearIndex", _wrap_glClearIndex, METH_VARARGS , _doc_glClearIndex},
	 { (char *)"glClearStencil", _wrap_glClearStencil, METH_VARARGS , _doc_glClearStencil},
	 { (char *)"glClipPlane", _wrap_glClipPlane, METH_VARARGS , _doc_glClipPlane},
	 { (char *)"glColorMask", _wrap_glColorMask, METH_VARARGS , _doc_glColorMask},
	 { (char *)"glColorMaterial", _wrap_glColorMaterial, METH_VARARGS , _doc_glColorMaterial},
	 { (char *)"glColorPointer", _wrap_glColorPointer, METH_VARARGS , _doc_glColorPointer},
	 { (char *)"glColorPointerub", _wrap_glColorPointerub, METH_VARARGS , _doc_glColorPointerub},
	 { (char *)"glColorPointerb", _wrap_glColorPointerb, METH_VARARGS , _doc_glColorPointerb},
	 { (char *)"glColorPointerus", _wrap_glColorPointerus, METH_VARARGS , _doc_glColorPointerus},
	 { (char *)"glColorPointers", _wrap_glColorPointers, METH_VARARGS , _doc_glColorPointers},
	 { (char *)"glColorPointerui", _wrap_glColorPointerui, METH_VARARGS , _doc_glColorPointerui},
	 { (char *)"glColorPointeri", _wrap_glColorPointeri, METH_VARARGS , _doc_glColorPointeri},
	 { (char *)"glColorPointerf", _wrap_glColorPointerf, METH_VARARGS , _doc_glColorPointerf},
	 { (char *)"glColorPointerd", _wrap_glColorPointerd, METH_VARARGS , _doc_glColorPointerd},
	 { (char *)"glCopyPixels", _wrap_glCopyPixels, METH_VARARGS , _doc_glCopyPixels},
	 { (char *)"glCopyTexImage1D", _wrap_glCopyTexImage1D, METH_VARARGS , _doc_glCopyTexImage1D},
	 { (char *)"glCopyTexImage2D", _wrap_glCopyTexImage2D, METH_VARARGS , _doc_glCopyTexImage2D},
	 { (char *)"glCopyTexSubImage1D", _wrap_glCopyTexSubImage1D, METH_VARARGS , _doc_glCopyTexSubImage1D},
	 { (char *)"glCopyTexSubImage2D", _wrap_glCopyTexSubImage2D, METH_VARARGS , _doc_glCopyTexSubImage2D},
	 { (char *)"glCullFace", _wrap_glCullFace, METH_VARARGS , _doc_glCullFace},
	 { (char *)"glDeleteLists", _wrap_glDeleteLists, METH_VARARGS , _doc_glDeleteLists},
	 { (char *)"glDeleteTextures", _wrap_glDeleteTextures, METH_VARARGS , _doc_glDeleteTextures},
	 { (char *)"glDepthFunc", _wrap_glDepthFunc, METH_VARARGS , _doc_glDepthFunc},
	 { (char *)"glDepthMask", _wrap_glDepthMask, METH_VARARGS , _doc_glDepthMask},
	 { (char *)"glDepthRange", _wrap_glDepthRange, METH_VARARGS , _doc_glDepthRange},
	 { (char *)"glDisable", _wrap_glDisable, METH_VARARGS , _doc_glDisable},
	 { (char *)"glDisableClientState", _wrap_glDisableClientState, METH_VARARGS , _doc_glDisableClientState},
	 { (char *)"glDrawArrays", _wrap_glDrawArrays, METH_VARARGS , _doc_glDrawArrays},
	 { (char *)"glDrawBuffer", _wrap_glDrawBuffer, METH_VARARGS , _doc_glDrawBuffer},
	 { (char *)"glDrawElements", _wrap_glDrawElements, METH_VARARGS , _doc_glDrawElements},
	 { (char *)"glDrawElementsub", _wrap_glDrawElementsub, METH_VARARGS , _doc_glDrawElementsub},
	 { (char *)"glDrawElementsus", _wrap_glDrawElementsus, METH_VARARGS , _doc_glDrawElementsus},
	 { (char *)"glDrawElementsui", _wrap_glDrawElementsui, METH_VARARGS , _doc_glDrawElementsui},
	 { (char *)"glDrawPixels", _wrap_glDrawPixels, METH_VARARGS , _doc_glDrawPixels},
	 { (char *)"glDrawPixelsub", _wrap_glDrawPixelsub, METH_VARARGS , _doc_glDrawPixelsub},
	 { (char *)"glDrawPixelsb", _wrap_glDrawPixelsb, METH_VARARGS , _doc_glDrawPixelsb},
	 { (char *)"glDrawPixelsus", _wrap_glDrawPixelsus, METH_VARARGS , _doc_glDrawPixelsus},
	 { (char *)"glDrawPixelss", _wrap_glDrawPixelss, METH_VARARGS , _doc_glDrawPixelss},
	 { (char *)"glDrawPixelsui", _wrap_glDrawPixelsui, METH_VARARGS , _doc_glDrawPixelsui},
	 { (char *)"glDrawPixelsi", _wrap_glDrawPixelsi, METH_VARARGS , _doc_glDrawPixelsi},
	 { (char *)"glDrawPixelsf", _wrap_glDrawPixelsf, METH_VARARGS , _doc_glDrawPixelsf},
	 { (char *)"glEdgeFlagPointer", _wrap_glEdgeFlagPointer, METH_VARARGS , _doc_glEdgeFlagPointer},
	 { (char *)"glEdgeFlagPointerb", _wrap_glEdgeFlagPointerb, METH_VARARGS , _doc_glEdgeFlagPointerb},
	 { (char *)"glEnable", _wrap_glEnable, METH_VARARGS , _doc_glEnable},
	 { (char *)"glEnableClientState", _wrap_glEnableClientState, METH_VARARGS , _doc_glEnableClientState},
	 { (char *)"glEnd", _wrap_glEnd, METH_VARARGS , _doc_glEnd},
	 { (char *)"glEndList", _wrap_glEndList, METH_VARARGS , _doc_glEndList},
	 { (char *)"glEvalMesh1", _wrap_glEvalMesh1, METH_VARARGS , _doc_glEvalMesh1},
	 { (char *)"glEvalMesh2", _wrap_glEvalMesh2, METH_VARARGS , _doc_glEvalMesh2},
	 { (char *)"glFeedbackBuffer", _wrap_glFeedbackBuffer, METH_VARARGS , _doc_glFeedbackBuffer},
	 { (char *)"glFinish", _wrap_glFinish, METH_VARARGS , _doc_glFinish},
	 { (char *)"glFlush", _wrap_glFlush, METH_VARARGS , _doc_glFlush},
	 { (char *)"glFogf", _wrap_glFogf, METH_VARARGS , _doc_glFogf},
	 { (char *)"glFogfv", _wrap_glFogfv, METH_VARARGS , _doc_glFogfv},
	 { (char *)"glFogi", _wrap_glFogi, METH_VARARGS , _doc_glFogi},
	 { (char *)"glFogiv", _wrap_glFogiv, METH_VARARGS , _doc_glFogiv},
	 { (char *)"glFrontFace", _wrap_glFrontFace, METH_VARARGS , _doc_glFrontFace},
	 { (char *)"glFrustum", _wrap_glFrustum, METH_VARARGS , _doc_glFrustum},
	 { (char *)"glGenLists", _wrap_glGenLists, METH_VARARGS , _doc_glGenLists},
	 { (char *)"glGenTextures", _wrap_glGenTextures, METH_VARARGS , _doc_glGenTextures},
	 { (char *)"glGetBooleanv", _wrap_glGetBooleanv, METH_VARARGS , _doc_glGetBooleanv},
	 { (char *)"glGetClipPlane", _wrap_glGetClipPlane, METH_VARARGS , _doc_glGetClipPlane},
	 { (char *)"glGetDoublev", _wrap_glGetDoublev, METH_VARARGS , _doc_glGetDoublev},
	 { (char *)"glGetFloatv", _wrap_glGetFloatv, METH_VARARGS , _doc_glGetFloatv},
	 { (char *)"glGetIntegerv", _wrap_glGetIntegerv, METH_VARARGS , _doc_glGetIntegerv},
	 { (char *)"glGetLightfv", _wrap_glGetLightfv, METH_VARARGS , _doc_glGetLightfv},
	 { (char *)"glGetLightiv", _wrap_glGetLightiv, METH_VARARGS , _doc_glGetLightiv},
	 { (char *)"glGetMapdv", _wrap_glGetMapdv, METH_VARARGS , _doc_glGetMapdv},
	 { (char *)"glGetMapfv", _wrap_glGetMapfv, METH_VARARGS , _doc_glGetMapfv},
	 { (char *)"glGetMapiv", _wrap_glGetMapiv, METH_VARARGS , _doc_glGetMapiv},
	 { (char *)"glGetMaterialfv", _wrap_glGetMaterialfv, METH_VARARGS , _doc_glGetMaterialfv},
	 { (char *)"glGetMaterialiv", _wrap_glGetMaterialiv, METH_VARARGS , _doc_glGetMaterialiv},
	 { (char *)"glGetPixelMapfv", _wrap_glGetPixelMapfv, METH_VARARGS , _doc_glGetPixelMapfv},
	 { (char *)"glGetPixelMapuiv", _wrap_glGetPixelMapuiv, METH_VARARGS , _doc_glGetPixelMapuiv},
	 { (char *)"glGetPixelMapusv", _wrap_glGetPixelMapusv, METH_VARARGS , _doc_glGetPixelMapusv},
	 { (char *)"glGetPolygonStipple", _wrap_glGetPolygonStipple, METH_VARARGS , _doc_glGetPolygonStipple},
	 { (char *)"glGetPolygonStippleub", _wrap_glGetPolygonStippleub, METH_VARARGS , _doc_glGetPolygonStippleub},
	 { (char *)"glGetString", _wrap_glGetString, METH_VARARGS , _doc_glGetString},
	 { (char *)"glGetTexEnvfv", _wrap_glGetTexEnvfv, METH_VARARGS , _doc_glGetTexEnvfv},
	 { (char *)"glGetTexEnviv", _wrap_glGetTexEnviv, METH_VARARGS , _doc_glGetTexEnviv},
	 { (char *)"glGetTexGendv", _wrap_glGetTexGendv, METH_VARARGS , _doc_glGetTexGendv},
	 { (char *)"glGetTexGenfv", _wrap_glGetTexGenfv, METH_VARARGS , _doc_glGetTexGenfv},
	 { (char *)"glGetTexGeniv", _wrap_glGetTexGeniv, METH_VARARGS , _doc_glGetTexGeniv},
	 { (char *)"glGetTexImage", _wrap_glGetTexImage, METH_VARARGS , _doc_glGetTexImage},
	 { (char *)"glGetTexImageub", _wrap_glGetTexImageub, METH_VARARGS , _doc_glGetTexImageub},
	 { (char *)"glGetTexImageb", _wrap_glGetTexImageb, METH_VARARGS , _doc_glGetTexImageb},
	 { (char *)"glGetTexImageus", _wrap_glGetTexImageus, METH_VARARGS , _doc_glGetTexImageus},
	 { (char *)"glGetTexImages", _wrap_glGetTexImages, METH_VARARGS , _doc_glGetTexImages},
	 { (char *)"glGetTexImageui", _wrap_glGetTexImageui, METH_VARARGS , _doc_glGetTexImageui},
	 { (char *)"glGetTexImagei", _wrap_glGetTexImagei, METH_VARARGS , _doc_glGetTexImagei},
	 { (char *)"glGetTexImagef", _wrap_glGetTexImagef, METH_VARARGS , _doc_glGetTexImagef},
	 { (char *)"glGetTexImaged", _wrap_glGetTexImaged, METH_VARARGS , _doc_glGetTexImaged},
	 { (char *)"glGetTexLevelParameterfv", _wrap_glGetTexLevelParameterfv, METH_VARARGS , _doc_glGetTexLevelParameterfv},
	 { (char *)"glGetTexLevelParameteriv", _wrap_glGetTexLevelParameteriv, METH_VARARGS , _doc_glGetTexLevelParameteriv},
	 { (char *)"glGetTexParameterfv", _wrap_glGetTexParameterfv, METH_VARARGS , _doc_glGetTexParameterfv},
	 { (char *)"glGetTexParameteriv", _wrap_glGetTexParameteriv, METH_VARARGS , _doc_glGetTexParameteriv},
	 { (char *)"glHint", _wrap_glHint, METH_VARARGS , _doc_glHint},
	 { (char *)"glIndexMask", _wrap_glIndexMask, METH_VARARGS , _doc_glIndexMask},
	 { (char *)"glIndexPointer", _wrap_glIndexPointer, METH_VARARGS , _doc_glIndexPointer},
	 { (char *)"glIndexPointerub", _wrap_glIndexPointerub, METH_VARARGS , _doc_glIndexPointerub},
	 { (char *)"glIndexPointerb", _wrap_glIndexPointerb, METH_VARARGS , _doc_glIndexPointerb},
	 { (char *)"glIndexPointers", _wrap_glIndexPointers, METH_VARARGS , _doc_glIndexPointers},
	 { (char *)"glIndexPointeri", _wrap_glIndexPointeri, METH_VARARGS , _doc_glIndexPointeri},
	 { (char *)"glIndexPointerf", _wrap_glIndexPointerf, METH_VARARGS , _doc_glIndexPointerf},
	 { (char *)"glIndexPointerd", _wrap_glIndexPointerd, METH_VARARGS , _doc_glIndexPointerd},
	 { (char *)"glInitNames", _wrap_glInitNames, METH_VARARGS , _doc_glInitNames},
	 { (char *)"glInterleavedArrays", _wrap_glInterleavedArrays, METH_VARARGS , _doc_glInterleavedArrays},
	 { (char *)"glIsEnabled", _wrap_glIsEnabled, METH_VARARGS , _doc_glIsEnabled},
	 { (char *)"glIsList", _wrap_glIsList, METH_VARARGS , _doc_glIsList},
	 { (char *)"glIsTexture", _wrap_glIsTexture, METH_VARARGS , _doc_glIsTexture},
	 { (char *)"glLightModelf", _wrap_glLightModelf, METH_VARARGS , _doc_glLightModelf},
	 { (char *)"glLightModelfv", _wrap_glLightModelfv, METH_VARARGS , _doc_glLightModelfv},
	 { (char *)"glLightModeli", _wrap_glLightModeli, METH_VARARGS , _doc_glLightModeli},
	 { (char *)"glLightModeliv", _wrap_glLightModeliv, METH_VARARGS , _doc_glLightModeliv},
	 { (char *)"glLightf", _wrap_glLightf, METH_VARARGS , _doc_glLightf},
	 { (char *)"glLightfv", _wrap_glLightfv, METH_VARARGS , _doc_glLightfv},
	 { (char *)"glLighti", _wrap_glLighti, METH_VARARGS , _doc_glLighti},
	 { (char *)"glLightiv", _wrap_glLightiv, METH_VARARGS , _doc_glLightiv},
	 { (char *)"glLineStipple", _wrap_glLineStipple, METH_VARARGS , _doc_glLineStipple},
	 { (char *)"glLineWidth", _wrap_glLineWidth, METH_VARARGS , _doc_glLineWidth},
	 { (char *)"glListBase", _wrap_glListBase, METH_VARARGS , _doc_glListBase},
	 { (char *)"glLoadIdentity", _wrap_glLoadIdentity, METH_VARARGS , _doc_glLoadIdentity},
	 { (char *)"glLoadMatrixd", _wrap_glLoadMatrixd, METH_VARARGS , _doc_glLoadMatrixd},
	 { (char *)"glLoadMatrixf", _wrap_glLoadMatrixf, METH_VARARGS , _doc_glLoadMatrixf},
	 { (char *)"glLoadName", _wrap_glLoadName, METH_VARARGS , _doc_glLoadName},
	 { (char *)"glLogicOp", _wrap_glLogicOp, METH_VARARGS , _doc_glLogicOp},
	 { (char *)"glMap1d", _wrap_glMap1d, METH_VARARGS , _doc_glMap1d},
	 { (char *)"glMap1f", _wrap_glMap1f, METH_VARARGS , _doc_glMap1f},
	 { (char *)"glMap2d", _wrap_glMap2d, METH_VARARGS , _doc_glMap2d},
	 { (char *)"glMap2f", _wrap_glMap2f, METH_VARARGS , _doc_glMap2f},
	 { (char *)"glMapGrid1d", _wrap_glMapGrid1d, METH_VARARGS , _doc_glMapGrid1d},
	 { (char *)"glMapGrid1f", _wrap_glMapGrid1f, METH_VARARGS , _doc_glMapGrid1f},
	 { (char *)"glMapGrid2d", _wrap_glMapGrid2d, METH_VARARGS , _doc_glMapGrid2d},
	 { (char *)"glMapGrid2f", _wrap_glMapGrid2f, METH_VARARGS , _doc_glMapGrid2f},
	 { (char *)"glMatrixMode", _wrap_glMatrixMode, METH_VARARGS , _doc_glMatrixMode},
	 { (char *)"glMultMatrixd", _wrap_glMultMatrixd, METH_VARARGS , _doc_glMultMatrixd},
	 { (char *)"glMultMatrixf", _wrap_glMultMatrixf, METH_VARARGS , _doc_glMultMatrixf},
	 { (char *)"glNewList", _wrap_glNewList, METH_VARARGS , _doc_glNewList},
	 { (char *)"glNormalPointer", _wrap_glNormalPointer, METH_VARARGS , _doc_glNormalPointer},
	 { (char *)"glNormalPointerb", _wrap_glNormalPointerb, METH_VARARGS , _doc_glNormalPointerb},
	 { (char *)"glNormalPointers", _wrap_glNormalPointers, METH_VARARGS , _doc_glNormalPointers},
	 { (char *)"glNormalPointeri", _wrap_glNormalPointeri, METH_VARARGS , _doc_glNormalPointeri},
	 { (char *)"glNormalPointerf", _wrap_glNormalPointerf, METH_VARARGS , _doc_glNormalPointerf},
	 { (char *)"glNormalPointerd", _wrap_glNormalPointerd, METH_VARARGS , _doc_glNormalPointerd},
	 { (char *)"glOrtho", _wrap_glOrtho, METH_VARARGS , _doc_glOrtho},
	 { (char *)"glPassThrough", _wrap_glPassThrough, METH_VARARGS , _doc_glPassThrough},
	 { (char *)"glPixelMapfv", _wrap_glPixelMapfv, METH_VARARGS , _doc_glPixelMapfv},
	 { (char *)"glPixelMapuiv", _wrap_glPixelMapuiv, METH_VARARGS , _doc_glPixelMapuiv},
	 { (char *)"glPixelMapusv", _wrap_glPixelMapusv, METH_VARARGS , _doc_glPixelMapusv},
	 { (char *)"glPixelStoref", _wrap_glPixelStoref, METH_VARARGS , _doc_glPixelStoref},
	 { (char *)"glPixelStorei", _wrap_glPixelStorei, METH_VARARGS , _doc_glPixelStorei},
	 { (char *)"glPixelTransferf", _wrap_glPixelTransferf, METH_VARARGS , _doc_glPixelTransferf},
	 { (char *)"glPixelTransferi", _wrap_glPixelTransferi, METH_VARARGS , _doc_glPixelTransferi},
	 { (char *)"glPixelZoom", _wrap_glPixelZoom, METH_VARARGS , _doc_glPixelZoom},
	 { (char *)"glPointSize", _wrap_glPointSize, METH_VARARGS , _doc_glPointSize},
	 { (char *)"glPolygonMode", _wrap_glPolygonMode, METH_VARARGS , _doc_glPolygonMode},
	 { (char *)"glPolygonOffset", _wrap_glPolygonOffset, METH_VARARGS , _doc_glPolygonOffset},
	 { (char *)"glPolygonStipple", _wrap_glPolygonStipple, METH_VARARGS , _doc_glPolygonStipple},
	 { (char *)"glPolygonStippleub", _wrap_glPolygonStippleub, METH_VARARGS , _doc_glPolygonStippleub},
	 { (char *)"glPopAttrib", _wrap_glPopAttrib, METH_VARARGS , _doc_glPopAttrib},
	 { (char *)"glPopClientAttrib", _wrap_glPopClientAttrib, METH_VARARGS , _doc_glPopClientAttrib},
	 { (char *)"glPopMatrix", _wrap_glPopMatrix, METH_VARARGS , _doc_glPopMatrix},
	 { (char *)"glPopName", _wrap_glPopName, METH_VARARGS , _doc_glPopName},
	 { (char *)"glPrioritizeTextures", _wrap_glPrioritizeTextures, METH_VARARGS , _doc_glPrioritizeTextures},
	 { (char *)"glPushAttrib", _wrap_glPushAttrib, METH_VARARGS , _doc_glPushAttrib},
	 { (char *)"glPushClientAttrib", _wrap_glPushClientAttrib, METH_VARARGS , _doc_glPushClientAttrib},
	 { (char *)"glPushMatrix", _wrap_glPushMatrix, METH_VARARGS , _doc_glPushMatrix},
	 { (char *)"glPushName", _wrap_glPushName, METH_VARARGS , _doc_glPushName},
	 { (char *)"glRasterPos2d", _wrap_glRasterPos2d, METH_VARARGS , _doc_glRasterPos2d},
	 { (char *)"glRasterPos2dv", _wrap_glRasterPos2dv, METH_VARARGS , _doc_glRasterPos2dv},
	 { (char *)"glRasterPos2f", _wrap_glRasterPos2f, METH_VARARGS , _doc_glRasterPos2f},
	 { (char *)"glRasterPos2fv", _wrap_glRasterPos2fv, METH_VARARGS , _doc_glRasterPos2fv},
	 { (char *)"glRasterPos2i", _wrap_glRasterPos2i, METH_VARARGS , _doc_glRasterPos2i},
	 { (char *)"glRasterPos2iv", _wrap_glRasterPos2iv, METH_VARARGS , _doc_glRasterPos2iv},
	 { (char *)"glRasterPos2s", _wrap_glRasterPos2s, METH_VARARGS , _doc_glRasterPos2s},
	 { (char *)"glRasterPos2sv", _wrap_glRasterPos2sv, METH_VARARGS , _doc_glRasterPos2sv},
	 { (char *)"glRasterPos3d", _wrap_glRasterPos3d, METH_VARARGS , _doc_glRasterPos3d},
	 { (char *)"glRasterPos3dv", _wrap_glRasterPos3dv, METH_VARARGS , _doc_glRasterPos3dv},
	 { (char *)"glRasterPos3f", _wrap_glRasterPos3f, METH_VARARGS , _doc_glRasterPos3f},
	 { (char *)"glRasterPos3fv", _wrap_glRasterPos3fv, METH_VARARGS , _doc_glRasterPos3fv},
	 { (char *)"glRasterPos3i", _wrap_glRasterPos3i, METH_VARARGS , _doc_glRasterPos3i},
	 { (char *)"glRasterPos3iv", _wrap_glRasterPos3iv, METH_VARARGS , _doc_glRasterPos3iv},
	 { (char *)"glRasterPos3s", _wrap_glRasterPos3s, METH_VARARGS , _doc_glRasterPos3s},
	 { (char *)"glRasterPos3sv", _wrap_glRasterPos3sv, METH_VARARGS , _doc_glRasterPos3sv},
	 { (char *)"glRasterPos4d", _wrap_glRasterPos4d, METH_VARARGS , _doc_glRasterPos4d},
	 { (char *)"glRasterPos4dv", _wrap_glRasterPos4dv, METH_VARARGS , _doc_glRasterPos4dv},
	 { (char *)"glRasterPos4f", _wrap_glRasterPos4f, METH_VARARGS , _doc_glRasterPos4f},
	 { (char *)"glRasterPos4fv", _wrap_glRasterPos4fv, METH_VARARGS , _doc_glRasterPos4fv},
	 { (char *)"glRasterPos4i", _wrap_glRasterPos4i, METH_VARARGS , _doc_glRasterPos4i},
	 { (char *)"glRasterPos4iv", _wrap_glRasterPos4iv, METH_VARARGS , _doc_glRasterPos4iv},
	 { (char *)"glRasterPos4s", _wrap_glRasterPos4s, METH_VARARGS , _doc_glRasterPos4s},
	 { (char *)"glRasterPos4sv", _wrap_glRasterPos4sv, METH_VARARGS , _doc_glRasterPos4sv},
	 { (char *)"glReadBuffer", _wrap_glReadBuffer, METH_VARARGS , _doc_glReadBuffer},
	 { (char *)"glReadPixels", _wrap_glReadPixels, METH_VARARGS , _doc_glReadPixels},
	 { (char *)"glReadPixelsub", _wrap_glReadPixelsub, METH_VARARGS , _doc_glReadPixelsub},
	 { (char *)"glReadPixelsb", _wrap_glReadPixelsb, METH_VARARGS , _doc_glReadPixelsb},
	 { (char *)"glReadPixelsus", _wrap_glReadPixelsus, METH_VARARGS , _doc_glReadPixelsus},
	 { (char *)"glReadPixelss", _wrap_glReadPixelss, METH_VARARGS , _doc_glReadPixelss},
	 { (char *)"glReadPixelsui", _wrap_glReadPixelsui, METH_VARARGS , _doc_glReadPixelsui},
	 { (char *)"glReadPixelsi", _wrap_glReadPixelsi, METH_VARARGS , _doc_glReadPixelsi},
	 { (char *)"glReadPixelsf", _wrap_glReadPixelsf, METH_VARARGS , _doc_glReadPixelsf},
	 { (char *)"glReadPixelsd", _wrap_glReadPixelsd, METH_VARARGS , _doc_glReadPixelsd},
	 { (char *)"glRectd", _wrap_glRectd, METH_VARARGS , _doc_glRectd},
	 { (char *)"glRectdv", _wrap_glRectdv, METH_VARARGS , _doc_glRectdv},
	 { (char *)"glRectf", _wrap_glRectf, METH_VARARGS , _doc_glRectf},
	 { (char *)"glRectfv", _wrap_glRectfv, METH_VARARGS , _doc_glRectfv},
	 { (char *)"glRecti", _wrap_glRecti, METH_VARARGS , _doc_glRecti},
	 { (char *)"glRectiv", _wrap_glRectiv, METH_VARARGS , _doc_glRectiv},
	 { (char *)"glRects", _wrap_glRects, METH_VARARGS , _doc_glRects},
	 { (char *)"glRectsv", _wrap_glRectsv, METH_VARARGS , _doc_glRectsv},
	 { (char *)"glRenderMode", _wrap_glRenderMode, METH_VARARGS , _doc_glRenderMode},
	 { (char *)"glRotated", _wrap_glRotated, METH_VARARGS , _doc_glRotated},
	 { (char *)"glRotatef", _wrap_glRotatef, METH_VARARGS , _doc_glRotatef},
	 { (char *)"glScaled", _wrap_glScaled, METH_VARARGS , _doc_glScaled},
	 { (char *)"glScalef", _wrap_glScalef, METH_VARARGS , _doc_glScalef},
	 { (char *)"glScissor", _wrap_glScissor, METH_VARARGS , _doc_glScissor},
	 { (char *)"glSelectBuffer", _wrap_glSelectBuffer, METH_VARARGS , _doc_glSelectBuffer},
	 { (char *)"glShadeModel", _wrap_glShadeModel, METH_VARARGS , _doc_glShadeModel},
	 { (char *)"glStencilFunc", _wrap_glStencilFunc, METH_VARARGS , _doc_glStencilFunc},
	 { (char *)"glStencilMask", _wrap_glStencilMask, METH_VARARGS , _doc_glStencilMask},
	 { (char *)"glStencilOp", _wrap_glStencilOp, METH_VARARGS , _doc_glStencilOp},
	 { (char *)"glTexCoordPointer", _wrap_glTexCoordPointer, METH_VARARGS , _doc_glTexCoordPointer},
	 { (char *)"glTexCoordPointerb", _wrap_glTexCoordPointerb, METH_VARARGS , _doc_glTexCoordPointerb},
	 { (char *)"glTexCoordPointers", _wrap_glTexCoordPointers, METH_VARARGS , _doc_glTexCoordPointers},
	 { (char *)"glTexCoordPointeri", _wrap_glTexCoordPointeri, METH_VARARGS , _doc_glTexCoordPointeri},
	 { (char *)"glTexCoordPointerf", _wrap_glTexCoordPointerf, METH_VARARGS , _doc_glTexCoordPointerf},
	 { (char *)"glTexCoordPointerd", _wrap_glTexCoordPointerd, METH_VARARGS , _doc_glTexCoordPointerd},
	 { (char *)"glTexEnvf", _wrap_glTexEnvf, METH_VARARGS , _doc_glTexEnvf},
	 { (char *)"glTexEnvfv", _wrap_glTexEnvfv, METH_VARARGS , _doc_glTexEnvfv},
	 { (char *)"glTexEnvi", _wrap_glTexEnvi, METH_VARARGS , _doc_glTexEnvi},
	 { (char *)"glTexEnviv", _wrap_glTexEnviv, METH_VARARGS , _doc_glTexEnviv},
	 { (char *)"glTexGend", _wrap_glTexGend, METH_VARARGS , _doc_glTexGend},
	 { (char *)"glTexGendv", _wrap_glTexGendv, METH_VARARGS , _doc_glTexGendv},
	 { (char *)"glTexGenf", _wrap_glTexGenf, METH_VARARGS , _doc_glTexGenf},
	 { (char *)"glTexGenfv", _wrap_glTexGenfv, METH_VARARGS , _doc_glTexGenfv},
	 { (char *)"glTexGeni", _wrap_glTexGeni, METH_VARARGS , _doc_glTexGeni},
	 { (char *)"glTexGeniv", _wrap_glTexGeniv, METH_VARARGS , _doc_glTexGeniv},
	 { (char *)"glTexImage1D", _wrap_glTexImage1D, METH_VARARGS , _doc_glTexImage1D},
	 { (char *)"glTexImage1Dub", _wrap_glTexImage1Dub, METH_VARARGS , _doc_glTexImage1Dub},
	 { (char *)"glTexImage1Db", _wrap_glTexImage1Db, METH_VARARGS , _doc_glTexImage1Db},
	 { (char *)"glTexImage1Dus", _wrap_glTexImage1Dus, METH_VARARGS , _doc_glTexImage1Dus},
	 { (char *)"glTexImage1Ds", _wrap_glTexImage1Ds, METH_VARARGS , _doc_glTexImage1Ds},
	 { (char *)"glTexImage1Dui", _wrap_glTexImage1Dui, METH_VARARGS , _doc_glTexImage1Dui},
	 { (char *)"glTexImage1Di", _wrap_glTexImage1Di, METH_VARARGS , _doc_glTexImage1Di},
	 { (char *)"glTexImage1Df", _wrap_glTexImage1Df, METH_VARARGS , _doc_glTexImage1Df},
	 { (char *)"glTexImage2D", _wrap_glTexImage2D, METH_VARARGS , _doc_glTexImage2D},
	 { (char *)"glTexImage2Dub", _wrap_glTexImage2Dub, METH_VARARGS , _doc_glTexImage2Dub},
	 { (char *)"glTexImage2Db", _wrap_glTexImage2Db, METH_VARARGS , _doc_glTexImage2Db},
	 { (char *)"glTexImage2Dus", _wrap_glTexImage2Dus, METH_VARARGS , _doc_glTexImage2Dus},
	 { (char *)"glTexImage2Ds", _wrap_glTexImage2Ds, METH_VARARGS , _doc_glTexImage2Ds},
	 { (char *)"glTexImage2Dui", _wrap_glTexImage2Dui, METH_VARARGS , _doc_glTexImage2Dui},
	 { (char *)"glTexImage2Di", _wrap_glTexImage2Di, METH_VARARGS , _doc_glTexImage2Di},
	 { (char *)"glTexImage2Df", _wrap_glTexImage2Df, METH_VARARGS , _doc_glTexImage2Df},
	 { (char *)"glTexParameterf", _wrap_glTexParameterf, METH_VARARGS , _doc_glTexParameterf},
	 { (char *)"glTexParameterfv", _wrap_glTexParameterfv, METH_VARARGS , _doc_glTexParameterfv},
	 { (char *)"glTexParameteri", _wrap_glTexParameteri, METH_VARARGS , _doc_glTexParameteri},
	 { (char *)"glTexParameteriv", _wrap_glTexParameteriv, METH_VARARGS , _doc_glTexParameteriv},
	 { (char *)"glTexSubImage1D", _wrap_glTexSubImage1D, METH_VARARGS , _doc_glTexSubImage1D},
	 { (char *)"glTexSubImage1Dub", _wrap_glTexSubImage1Dub, METH_VARARGS , _doc_glTexSubImage1Dub},
	 { (char *)"glTexSubImage1Db", _wrap_glTexSubImage1Db, METH_VARARGS , _doc_glTexSubImage1Db},
	 { (char *)"glTexSubImage1Dus", _wrap_glTexSubImage1Dus, METH_VARARGS , _doc_glTexSubImage1Dus},
	 { (char *)"glTexSubImage1Ds", _wrap_glTexSubImage1Ds, METH_VARARGS , _doc_glTexSubImage1Ds},
	 { (char *)"glTexSubImage1Dui", _wrap_glTexSubImage1Dui, METH_VARARGS , _doc_glTexSubImage1Dui},
	 { (char *)"glTexSubImage1Di", _wrap_glTexSubImage1Di, METH_VARARGS , _doc_glTexSubImage1Di},
	 { (char *)"glTexSubImage1Df", _wrap_glTexSubImage1Df, METH_VARARGS , _doc_glTexSubImage1Df},
	 { (char *)"glTexSubImage2D", _wrap_glTexSubImage2D, METH_VARARGS , _doc_glTexSubImage2D},
	 { (char *)"glTexSubImage2Dub", _wrap_glTexSubImage2Dub, METH_VARARGS , _doc_glTexSubImage2Dub},
	 { (char *)"glTexSubImage2Db", _wrap_glTexSubImage2Db, METH_VARARGS , _doc_glTexSubImage2Db},
	 { (char *)"glTexSubImage2Dus", _wrap_glTexSubImage2Dus, METH_VARARGS , _doc_glTexSubImage2Dus},
	 { (char *)"glTexSubImage2Ds", _wrap_glTexSubImage2Ds, METH_VARARGS , _doc_glTexSubImage2Ds},
	 { (char *)"glTexSubImage2Dui", _wrap_glTexSubImage2Dui, METH_VARARGS , _doc_glTexSubImage2Dui},
	 { (char *)"glTexSubImage2Di", _wrap_glTexSubImage2Di, METH_VARARGS , _doc_glTexSubImage2Di},
	 { (char *)"glTexSubImage2Df", _wrap_glTexSubImage2Df, METH_VARARGS , _doc_glTexSubImage2Df},
	 { (char *)"glTranslated", _wrap_glTranslated, METH_VARARGS , _doc_glTranslated},
	 { (char *)"glTranslatef", _wrap_glTranslatef, METH_VARARGS , _doc_glTranslatef},
	 { (char *)"glVertexPointer", _wrap_glVertexPointer, METH_VARARGS , _doc_glVertexPointer},
	 { (char *)"glVertexPointerb", _wrap_glVertexPointerb, METH_VARARGS , _doc_glVertexPointerb},
	 { (char *)"glVertexPointers", _wrap_glVertexPointers, METH_VARARGS , _doc_glVertexPointers},
	 { (char *)"glVertexPointeri", _wrap_glVertexPointeri, METH_VARARGS , _doc_glVertexPointeri},
	 { (char *)"glVertexPointerf", _wrap_glVertexPointerf, METH_VARARGS , _doc_glVertexPointerf},
	 { (char *)"glVertexPointerd", _wrap_glVertexPointerd, METH_VARARGS , _doc_glVertexPointerd},
	 { (char *)"glViewport", _wrap_glViewport, METH_VARARGS , _doc_glViewport},
	 { NULL, NULL }
};


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


static swig_type_info *swig_types_initial[] = {
0
};


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

static swig_const_info swig_const_table[] = {
{ SWIG_PY_STRING,  (char*)"__version__", 0, 0, (void *)"1.1", 0},
{ SWIG_PY_STRING,  (char*)"__date__", 0, 0, (void *)"2003/10/19 04:09:43", 0},
{ SWIG_PY_INT,     (char *)"__api_version__", (long) 257, 0, 0, 0},
{ SWIG_PY_STRING,  (char*)"__author__", 0, 0, (void *)"Tarn Weisner Burton <twburton@users.sourceforge.net>\nMike C. Fletcher <mcfletch@users.sourceforge.net>", 0},
{ SWIG_PY_STRING,  (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", 0},
{ SWIG_PY_INT,     (char *)"GL_VERSION_1_1", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM", (long) 0x0100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LOAD", (long) 0x0101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RETURN", (long) 0x0102, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MULT", (long) 0x0103, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ADD", (long) 0x0104, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NEVER", (long) 0x0200, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LESS", (long) 0x0201, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EQUAL", (long) 0x0202, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LEQUAL", (long) 0x0203, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GREATER", (long) 0x0204, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NOTEQUAL", (long) 0x0205, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GEQUAL", (long) 0x0206, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALWAYS", (long) 0x0207, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_BIT", (long) 0x00000001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_BIT", (long) 0x00000002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_BIT", (long) 0x00000004, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_BIT", (long) 0x00000008, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_STIPPLE_BIT", (long) 0x00000010, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MODE_BIT", (long) 0x00000020, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHTING_BIT", (long) 0x00000040, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_BIT", (long) 0x00000080, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_BUFFER_BIT", (long) 0x00000100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_BUFFER_BIT", (long) 0x00000200, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_BUFFER_BIT", (long) 0x00000400, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VIEWPORT_BIT", (long) 0x00000800, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TRANSFORM_BIT", (long) 0x00001000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ENABLE_BIT", (long) 0x00002000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_BUFFER_BIT", (long) 0x00004000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_HINT_BIT", (long) 0x00008000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EVAL_BIT", (long) 0x00010000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIST_BIT", (long) 0x00020000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BIT", (long) 0x00040000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SCISSOR_BIT", (long) 0x00080000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALL_ATTRIB_BITS", (long) 0x000fffff, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINTS", (long) 0x0000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINES", (long) 0x0001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_LOOP", (long) 0x0002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_STRIP", (long) 0x0003, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TRIANGLES", (long) 0x0004, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TRIANGLE_STRIP", (long) 0x0005, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TRIANGLE_FAN", (long) 0x0006, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_QUADS", (long) 0x0007, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_QUAD_STRIP", (long) 0x0008, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON", (long) 0x0009, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ZERO", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ONE", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SRC_COLOR", (long) 0x0300, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ONE_MINUS_SRC_COLOR", (long) 0x0301, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SRC_ALPHA", (long) 0x0302, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ONE_MINUS_SRC_ALPHA", (long) 0x0303, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DST_ALPHA", (long) 0x0304, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ONE_MINUS_DST_ALPHA", (long) 0x0305, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DST_COLOR", (long) 0x0306, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ONE_MINUS_DST_COLOR", (long) 0x0307, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SRC_ALPHA_SATURATE", (long) 0x0308, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TRUE", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FALSE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE0", (long) 0x3000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE1", (long) 0x3001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE2", (long) 0x3002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE3", (long) 0x3003, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE4", (long) 0x3004, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIP_PLANE5", (long) 0x3005, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BYTE", (long) 0x1400, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNSIGNED_BYTE", (long) 0x1401, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SHORT", (long) 0x1402, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNSIGNED_SHORT", (long) 0x1403, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INT", (long) 0x1404, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNSIGNED_INT", (long) 0x1405, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FLOAT", (long) 0x1406, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_2_BYTES", (long) 0x1407, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_3_BYTES", (long) 0x1408, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_4_BYTES", (long) 0x1409, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DOUBLE", (long) 0x140A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NONE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FRONT_LEFT", (long) 0x0400, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FRONT_RIGHT", (long) 0x0401, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BACK_LEFT", (long) 0x0402, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BACK_RIGHT", (long) 0x0403, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FRONT", (long) 0x0404, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BACK", (long) 0x0405, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LEFT", (long) 0x0406, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RIGHT", (long) 0x0407, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FRONT_AND_BACK", (long) 0x0408, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUX0", (long) 0x0409, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUX1", (long) 0x040A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUX2", (long) 0x040B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUX3", (long) 0x040C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NO_ERROR", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INVALID_ENUM", (long) 0x0500, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INVALID_VALUE", (long) 0x0501, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INVALID_OPERATION", (long) 0x0502, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STACK_OVERFLOW", (long) 0x0503, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STACK_UNDERFLOW", (long) 0x0504, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OUT_OF_MEMORY", (long) 0x0505, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_2D", (long) 0x0600, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_3D", (long) 0x0601, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_3D_COLOR", (long) 0x0602, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_3D_COLOR_TEXTURE", (long) 0x0603, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_4D_COLOR_TEXTURE", (long) 0x0604, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PASS_THROUGH_TOKEN", (long) 0x0700, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_TOKEN", (long) 0x0701, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_TOKEN", (long) 0x0702, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_TOKEN", (long) 0x0703, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BITMAP_TOKEN", (long) 0x0704, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DRAW_PIXEL_TOKEN", (long) 0x0705, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COPY_PIXEL_TOKEN", (long) 0x0706, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_RESET_TOKEN", (long) 0x0707, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EXP", (long) 0x0800, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EXP2", (long) 0x0801, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CW", (long) 0x0900, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CCW", (long) 0x0901, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COEFF", (long) 0x0A00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ORDER", (long) 0x0A01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DOMAIN", (long) 0x0A02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_COLOR", (long) 0x0B00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_INDEX", (long) 0x0B01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_NORMAL", (long) 0x0B02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_TEXTURE_COORDS", (long) 0x0B03, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_COLOR", (long) 0x0B04, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_INDEX", (long) 0x0B05, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_TEXTURE_COORDS", (long) 0x0B06, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_POSITION", (long) 0x0B07, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_POSITION_VALID", (long) 0x0B08, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CURRENT_RASTER_DISTANCE", (long) 0x0B09, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_SMOOTH", (long) 0x0B10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_SIZE", (long) 0x0B11, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_SIZE_RANGE", (long) 0x0B12, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_SIZE_GRANULARITY", (long) 0x0B13, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_SMOOTH", (long) 0x0B20, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_WIDTH", (long) 0x0B21, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_WIDTH_RANGE", (long) 0x0B22, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_WIDTH_GRANULARITY", (long) 0x0B23, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_STIPPLE", (long) 0x0B24, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_STIPPLE_PATTERN", (long) 0x0B25, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_STIPPLE_REPEAT", (long) 0x0B26, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIST_MODE", (long) 0x0B30, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_LIST_NESTING", (long) 0x0B31, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIST_BASE", (long) 0x0B32, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIST_INDEX", (long) 0x0B33, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_MODE", (long) 0x0B40, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_SMOOTH", (long) 0x0B41, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_STIPPLE", (long) 0x0B42, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EDGE_FLAG", (long) 0x0B43, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CULL_FACE", (long) 0x0B44, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CULL_FACE_MODE", (long) 0x0B45, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FRONT_FACE", (long) 0x0B46, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHTING", (long) 0x0B50, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT_MODEL_LOCAL_VIEWER", (long) 0x0B51, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT_MODEL_TWO_SIDE", (long) 0x0B52, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT_MODEL_AMBIENT", (long) 0x0B53, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SHADE_MODEL", (long) 0x0B54, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_MATERIAL_FACE", (long) 0x0B55, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_MATERIAL_PARAMETER", (long) 0x0B56, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_MATERIAL", (long) 0x0B57, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG", (long) 0x0B60, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_INDEX", (long) 0x0B61, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_DENSITY", (long) 0x0B62, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_START", (long) 0x0B63, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_END", (long) 0x0B64, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_MODE", (long) 0x0B65, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_COLOR", (long) 0x0B66, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_RANGE", (long) 0x0B70, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_TEST", (long) 0x0B71, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_WRITEMASK", (long) 0x0B72, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_CLEAR_VALUE", (long) 0x0B73, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_FUNC", (long) 0x0B74, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_CLEAR_VALUE", (long) 0x0B80, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_TEST", (long) 0x0B90, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_CLEAR_VALUE", (long) 0x0B91, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_FUNC", (long) 0x0B92, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_VALUE_MASK", (long) 0x0B93, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_FAIL", (long) 0x0B94, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_PASS_DEPTH_FAIL", (long) 0x0B95, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_PASS_DEPTH_PASS", (long) 0x0B96, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_REF", (long) 0x0B97, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_WRITEMASK", (long) 0x0B98, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MATRIX_MODE", (long) 0x0BA0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NORMALIZE", (long) 0x0BA1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VIEWPORT", (long) 0x0BA2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MODELVIEW_STACK_DEPTH", (long) 0x0BA3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PROJECTION_STACK_DEPTH", (long) 0x0BA4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_STACK_DEPTH", (long) 0x0BA5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MODELVIEW_MATRIX", (long) 0x0BA6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PROJECTION_MATRIX", (long) 0x0BA7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_MATRIX", (long) 0x0BA8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ATTRIB_STACK_DEPTH", (long) 0x0BB0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIENT_ATTRIB_STACK_DEPTH", (long) 0x0BB1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_TEST", (long) 0x0BC0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_TEST_FUNC", (long) 0x0BC1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_TEST_REF", (long) 0x0BC2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DITHER", (long) 0x0BD0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLEND_DST", (long) 0x0BE0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLEND_SRC", (long) 0x0BE1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLEND", (long) 0x0BE2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LOGIC_OP_MODE", (long) 0x0BF0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_LOGIC_OP", (long) 0x0BF1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_LOGIC_OP", (long) 0x0BF2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUX_BUFFERS", (long) 0x0C00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DRAW_BUFFER", (long) 0x0C01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_READ_BUFFER", (long) 0x0C02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SCISSOR_BOX", (long) 0x0C10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SCISSOR_TEST", (long) 0x0C11, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_CLEAR_VALUE", (long) 0x0C20, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_WRITEMASK", (long) 0x0C21, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_CLEAR_VALUE", (long) 0x0C22, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_WRITEMASK", (long) 0x0C23, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_MODE", (long) 0x0C30, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA_MODE", (long) 0x0C31, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DOUBLEBUFFER", (long) 0x0C32, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STEREO", (long) 0x0C33, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RENDER_MODE", (long) 0x0C40, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PERSPECTIVE_CORRECTION_HINT", (long) 0x0C50, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT_SMOOTH_HINT", (long) 0x0C51, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE_SMOOTH_HINT", (long) 0x0C52, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_SMOOTH_HINT", (long) 0x0C53, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FOG_HINT", (long) 0x0C54, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GEN_S", (long) 0x0C60, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GEN_T", (long) 0x0C61, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GEN_R", (long) 0x0C62, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GEN_Q", (long) 0x0C63, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_I", (long) 0x0C70, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_S_TO_S", (long) 0x0C71, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_R", (long) 0x0C72, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_G", (long) 0x0C73, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_B", (long) 0x0C74, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_A", (long) 0x0C75, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_R_TO_R", (long) 0x0C76, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_G_TO_G", (long) 0x0C77, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_B_TO_B", (long) 0x0C78, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_A_TO_A", (long) 0x0C79, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_I_SIZE", (long) 0x0CB0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_S_TO_S_SIZE", (long) 0x0CB1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_R_SIZE", (long) 0x0CB2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_G_SIZE", (long) 0x0CB3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_B_SIZE", (long) 0x0CB4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_I_TO_A_SIZE", (long) 0x0CB5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_R_TO_R_SIZE", (long) 0x0CB6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_G_TO_G_SIZE", (long) 0x0CB7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_B_TO_B_SIZE", (long) 0x0CB8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PIXEL_MAP_A_TO_A_SIZE", (long) 0x0CB9, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_SWAP_BYTES", (long) 0x0CF0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_LSB_FIRST", (long) 0x0CF1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_ROW_LENGTH", (long) 0x0CF2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_SKIP_ROWS", (long) 0x0CF3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_SKIP_PIXELS", (long) 0x0CF4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_UNPACK_ALIGNMENT", (long) 0x0CF5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_SWAP_BYTES", (long) 0x0D00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_LSB_FIRST", (long) 0x0D01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_ROW_LENGTH", (long) 0x0D02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_SKIP_ROWS", (long) 0x0D03, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_SKIP_PIXELS", (long) 0x0D04, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PACK_ALIGNMENT", (long) 0x0D05, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP_COLOR", (long) 0x0D10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP_STENCIL", (long) 0x0D11, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_SHIFT", (long) 0x0D12, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_OFFSET", (long) 0x0D13, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RED_SCALE", (long) 0x0D14, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RED_BIAS", (long) 0x0D15, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ZOOM_X", (long) 0x0D16, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ZOOM_Y", (long) 0x0D17, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GREEN_SCALE", (long) 0x0D18, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GREEN_BIAS", (long) 0x0D19, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLUE_SCALE", (long) 0x0D1A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLUE_BIAS", (long) 0x0D1B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_SCALE", (long) 0x0D1C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_BIAS", (long) 0x0D1D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_SCALE", (long) 0x0D1E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_BIAS", (long) 0x0D1F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_EVAL_ORDER", (long) 0x0D30, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_LIGHTS", (long) 0x0D31, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_CLIP_PLANES", (long) 0x0D32, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_TEXTURE_SIZE", (long) 0x0D33, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_PIXEL_MAP_TABLE", (long) 0x0D34, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_ATTRIB_STACK_DEPTH", (long) 0x0D35, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_MODELVIEW_STACK_DEPTH", (long) 0x0D36, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_NAME_STACK_DEPTH", (long) 0x0D37, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_PROJECTION_STACK_DEPTH", (long) 0x0D38, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_TEXTURE_STACK_DEPTH", (long) 0x0D39, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_VIEWPORT_DIMS", (long) 0x0D3A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", (long) 0x0D3B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SUBPIXEL_BITS", (long) 0x0D50, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_BITS", (long) 0x0D51, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RED_BITS", (long) 0x0D52, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GREEN_BITS", (long) 0x0D53, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLUE_BITS", (long) 0x0D54, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA_BITS", (long) 0x0D55, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_BITS", (long) 0x0D56, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_BITS", (long) 0x0D57, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_RED_BITS", (long) 0x0D58, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_GREEN_BITS", (long) 0x0D59, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_BLUE_BITS", (long) 0x0D5A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ACCUM_ALPHA_BITS", (long) 0x0D5B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NAME_STACK_DEPTH", (long) 0x0D70, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AUTO_NORMAL", (long) 0x0D80, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_COLOR_4", (long) 0x0D90, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_INDEX", (long) 0x0D91, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_NORMAL", (long) 0x0D92, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_TEXTURE_COORD_1", (long) 0x0D93, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_TEXTURE_COORD_2", (long) 0x0D94, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_TEXTURE_COORD_3", (long) 0x0D95, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_TEXTURE_COORD_4", (long) 0x0D96, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_VERTEX_3", (long) 0x0D97, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_VERTEX_4", (long) 0x0D98, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_COLOR_4", (long) 0x0DB0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_INDEX", (long) 0x0DB1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_NORMAL", (long) 0x0DB2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_TEXTURE_COORD_1", (long) 0x0DB3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_TEXTURE_COORD_2", (long) 0x0DB4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_TEXTURE_COORD_3", (long) 0x0DB5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_TEXTURE_COORD_4", (long) 0x0DB6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_VERTEX_3", (long) 0x0DB7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_VERTEX_4", (long) 0x0DB8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_GRID_DOMAIN", (long) 0x0DD0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP1_GRID_SEGMENTS", (long) 0x0DD1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_GRID_DOMAIN", (long) 0x0DD2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MAP2_GRID_SEGMENTS", (long) 0x0DD3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_1D", (long) 0x0DE0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_2D", (long) 0x0DE1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FEEDBACK_BUFFER_POINTER", (long) 0x0DF0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FEEDBACK_BUFFER_SIZE", (long) 0x0DF1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FEEDBACK_BUFFER_TYPE", (long) 0x0DF2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SELECTION_BUFFER_POINTER", (long) 0x0DF3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SELECTION_BUFFER_SIZE", (long) 0x0DF4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_WIDTH", (long) 0x1000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_HEIGHT", (long) 0x1001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_INTERNAL_FORMAT", (long) 0x1003, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BORDER_COLOR", (long) 0x1004, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BORDER", (long) 0x1005, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DONT_CARE", (long) 0x1100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FASTEST", (long) 0x1101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NICEST", (long) 0x1102, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT0", (long) 0x4000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT1", (long) 0x4001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT2", (long) 0x4002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT3", (long) 0x4003, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT4", (long) 0x4004, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT5", (long) 0x4005, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT6", (long) 0x4006, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LIGHT7", (long) 0x4007, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AMBIENT", (long) 0x1200, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DIFFUSE", (long) 0x1201, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SPECULAR", (long) 0x1202, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POSITION", (long) 0x1203, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SPOT_DIRECTION", (long) 0x1204, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SPOT_EXPONENT", (long) 0x1205, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SPOT_CUTOFF", (long) 0x1206, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CONSTANT_ATTENUATION", (long) 0x1207, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINEAR_ATTENUATION", (long) 0x1208, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_QUADRATIC_ATTENUATION", (long) 0x1209, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COMPILE", (long) 0x1300, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COMPILE_AND_EXECUTE", (long) 0x1301, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLEAR", (long) 0x1500, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AND", (long) 0x1501, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AND_REVERSE", (long) 0x1502, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COPY", (long) 0x1503, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AND_INVERTED", (long) 0x1504, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NOOP", (long) 0x1505, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_XOR", (long) 0x1506, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OR", (long) 0x1507, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NOR", (long) 0x1508, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EQUIV", (long) 0x1509, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INVERT", (long) 0x150A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OR_REVERSE", (long) 0x150B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COPY_INVERTED", (long) 0x150C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OR_INVERTED", (long) 0x150D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NAND", (long) 0x150E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SET", (long) 0x150F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EMISSION", (long) 0x1600, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SHININESS", (long) 0x1601, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_AMBIENT_AND_DIFFUSE", (long) 0x1602, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_INDEXES", (long) 0x1603, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MODELVIEW", (long) 0x1700, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PROJECTION", (long) 0x1701, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE", (long) 0x1702, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR", (long) 0x1800, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH", (long) 0x1801, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL", (long) 0x1802, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_INDEX", (long) 0x1900, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_STENCIL_INDEX", (long) 0x1901, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DEPTH_COMPONENT", (long) 0x1902, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RED", (long) 0x1903, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_GREEN", (long) 0x1904, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BLUE", (long) 0x1905, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA", (long) 0x1906, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB", (long) 0x1907, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA", (long) 0x1908, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE", (long) 0x1909, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE_ALPHA", (long) 0x190A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_BITMAP", (long) 0x1A00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POINT", (long) 0x1B00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINE", (long) 0x1B01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FILL", (long) 0x1B02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RENDER", (long) 0x1C00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FEEDBACK", (long) 0x1C01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SELECT", (long) 0x1C02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_FLAT", (long) 0x1D00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SMOOTH", (long) 0x1D01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_KEEP", (long) 0x1E00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_REPLACE", (long) 0x1E01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INCR", (long) 0x1E02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DECR", (long) 0x1E03, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VENDOR", (long) 0x1F00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RENDERER", (long) 0x1F01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERSION", (long) 0x1F02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EXTENSIONS", (long) 0x1F03, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_S", (long) 0x2000, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T", (long) 0x2001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_R", (long) 0x2002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_Q", (long) 0x2003, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_MODULATE", (long) 0x2100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_DECAL", (long) 0x2101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_ENV_MODE", (long) 0x2200, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_ENV_COLOR", (long) 0x2201, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_ENV", (long) 0x2300, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EYE_LINEAR", (long) 0x2400, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OBJECT_LINEAR", (long) 0x2401, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_SPHERE_MAP", (long) 0x2402, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GEN_MODE", (long) 0x2500, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_OBJECT_PLANE", (long) 0x2501, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EYE_PLANE", (long) 0x2502, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NEAREST", (long) 0x2600, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINEAR", (long) 0x2601, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NEAREST_MIPMAP_NEAREST", (long) 0x2700, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINEAR_MIPMAP_NEAREST", (long) 0x2701, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NEAREST_MIPMAP_LINEAR", (long) 0x2702, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LINEAR_MIPMAP_LINEAR", (long) 0x2703, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_MAG_FILTER", (long) 0x2800, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_MIN_FILTER", (long) 0x2801, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_WRAP_S", (long) 0x2802, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_WRAP_T", (long) 0x2803, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLAMP", (long) 0x2900, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_REPEAT", (long) 0x2901, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIENT_PIXEL_STORE_BIT", (long) 0x00000001, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIENT_VERTEX_ARRAY_BIT", (long) 0x00000002, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_CLIENT_ALL_ATTRIB_BITS", (long) 0xffffffff, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_OFFSET_FACTOR", (long) 0x8038, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_OFFSET_UNITS", (long) 0x2A00, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_OFFSET_POINT", (long) 0x2A01, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_OFFSET_LINE", (long) 0x2A02, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_POLYGON_OFFSET_FILL", (long) 0x8037, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA4", (long) 0x803B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA8", (long) 0x803C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA12", (long) 0x803D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_ALPHA16", (long) 0x803E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE4", (long) 0x803F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE8", (long) 0x8040, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE12", (long) 0x8041, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE16", (long) 0x8042, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE4_ALPHA4", (long) 0x8043, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE6_ALPHA2", (long) 0x8044, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE8_ALPHA8", (long) 0x8045, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE12_ALPHA4", (long) 0x8046, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE12_ALPHA12", (long) 0x8047, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LUMINANCE16_ALPHA16", (long) 0x8048, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INTENSITY", (long) 0x8049, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INTENSITY4", (long) 0x804A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INTENSITY8", (long) 0x804B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INTENSITY12", (long) 0x804C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INTENSITY16", (long) 0x804D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_R3_G3_B2", (long) 0x2A10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB4", (long) 0x804F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB5", (long) 0x8050, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB8", (long) 0x8051, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB10", (long) 0x8052, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB12", (long) 0x8053, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB16", (long) 0x8054, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA2", (long) 0x8055, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA4", (long) 0x8056, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB5_A1", (long) 0x8057, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA8", (long) 0x8058, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGB10_A2", (long) 0x8059, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA12", (long) 0x805A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_RGBA16", (long) 0x805B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_RED_SIZE", (long) 0x805C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_GREEN_SIZE", (long) 0x805D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BLUE_SIZE", (long) 0x805E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_ALPHA_SIZE", (long) 0x805F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_LUMINANCE_SIZE", (long) 0x8060, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_INTENSITY_SIZE", (long) 0x8061, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PROXY_TEXTURE_1D", (long) 0x8063, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_PROXY_TEXTURE_2D", (long) 0x8064, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_PRIORITY", (long) 0x8066, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_RESIDENT", (long) 0x8067, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BINDING_1D", (long) 0x8068, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_BINDING_2D", (long) 0x8069, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERTEX_ARRAY", (long) 0x8074, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NORMAL_ARRAY", (long) 0x8075, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_ARRAY", (long) 0x8076, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_ARRAY", (long) 0x8077, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COORD_ARRAY", (long) 0x8078, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EDGE_FLAG_ARRAY", (long) 0x8079, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERTEX_ARRAY_SIZE", (long) 0x807A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERTEX_ARRAY_TYPE", (long) 0x807B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERTEX_ARRAY_STRIDE", (long) 0x807C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NORMAL_ARRAY_TYPE", (long) 0x807E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NORMAL_ARRAY_STRIDE", (long) 0x807F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_ARRAY_SIZE", (long) 0x8081, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_ARRAY_TYPE", (long) 0x8082, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_ARRAY_STRIDE", (long) 0x8083, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_ARRAY_TYPE", (long) 0x8085, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_ARRAY_STRIDE", (long) 0x8086, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COORD_ARRAY_SIZE", (long) 0x8088, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COORD_ARRAY_TYPE", (long) 0x8089, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COORD_ARRAY_STRIDE", (long) 0x808A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EDGE_FLAG_ARRAY_STRIDE", (long) 0x808C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_VERTEX_ARRAY_POINTER", (long) 0x808E, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_NORMAL_ARRAY_POINTER", (long) 0x808F, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_COLOR_ARRAY_POINTER", (long) 0x8090, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_INDEX_ARRAY_POINTER", (long) 0x8091, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COORD_ARRAY_POINTER", (long) 0x8092, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_EDGE_FLAG_ARRAY_POINTER", (long) 0x8093, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_V2F", (long) 0x2A20, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_V3F", (long) 0x2A21, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_C4UB_V2F", (long) 0x2A22, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_C4UB_V3F", (long) 0x2A23, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_C3F_V3F", (long) 0x2A24, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_N3F_V3F", (long) 0x2A25, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_C4F_N3F_V3F", (long) 0x2A26, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T2F_V3F", (long) 0x2A27, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T4F_V4F", (long) 0x2A28, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T2F_C4UB_V3F", (long) 0x2A29, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T2F_C3F_V3F", (long) 0x2A2A, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T2F_N3F_V3F", (long) 0x2A2B, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T2F_C4F_N3F_V3F", (long) 0x2A2C, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_T4F_C4F_N3F_V4F", (long) 0x2A2D, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_LOGIC_OP", (long) 0x0BF1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GL_TEXTURE_COMPONENTS", (long) 0x1003, 0, 0, 0},
{0}};

#ifdef __cplusplus
}
#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();
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
    d = PyModule_GetDict(m);
    
    if (!typeinit) {
        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);
    
    
    #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);
    
}

