Windows2003-3790/multimedia/opengl/gls/lib/g_glstub.c

/*
** Copyright 1995-2095, Silicon Graphics, Inc.
** All Rights Reserved.
** 
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
** the contents of this file may not be disclosed to third parties, copied or
** duplicated in any form, in whole or in part, without the prior written
** permission of Silicon Graphics, Inc.
** 
** RESTRICTED RIGHTS LEGEND:
** Use, duplication or disclosure by the Government is subject to restrictions
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
** rights reserved under the Copyright Laws of the United States.
*/

/* GENERATED FILE: DO NOT EDIT */

#include "glslib.h"

void glNewList(GLuint list, GLenum mode) {
    fprintf(stderr, "stub_glNewList\n");
}

void glEndList(void) {
    fprintf(stderr, "stub_glEndList\n");
}

void glCallList(GLuint list) {
    fprintf(stderr, "stub_glCallList\n");
}

void glCallLists(GLsizei n, GLenum type, const GLvoid *lists) {
    fprintf(stderr, "stub_glCallLists\n");
}

void glDeleteLists(GLuint list, GLsizei range) {
    fprintf(stderr, "stub_glDeleteLists\n");
}

GLuint glGenLists(GLsizei range) {
    fprintf(stderr, "stub_glGenLists\n");
    return 0;
}

void glListBase(GLuint base) {
    fprintf(stderr, "stub_glListBase\n");
}

void glBegin(GLenum mode) {
    fprintf(stderr, "stub_glBegin\n");
}

void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {
    fprintf(stderr, "stub_glBitmap\n");
}

void glColor3b(GLbyte red, GLbyte green, GLbyte blue) {
    fprintf(stderr, "stub_glColor3b\n");
}

void glColor3bv(const GLbyte *v) {
    fprintf(stderr, "stub_glColor3bv\n");
}

void glColor3d(GLdouble red, GLdouble green, GLdouble blue) {
    fprintf(stderr, "stub_glColor3d\n");
}

void glColor3dv(const GLdouble *v) {
    fprintf(stderr, "stub_glColor3dv\n");
}

void glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
    fprintf(stderr, "stub_glColor3f\n");
}

void glColor3fv(const GLfloat *v) {
    fprintf(stderr, "stub_glColor3fv\n");
}

void glColor3i(GLint red, GLint green, GLint blue) {
    fprintf(stderr, "stub_glColor3i\n");
}

void glColor3iv(const GLint *v) {
    fprintf(stderr, "stub_glColor3iv\n");
}

void glColor3s(GLshort red, GLshort green, GLshort blue) {
    fprintf(stderr, "stub_glColor3s\n");
}

void glColor3sv(const GLshort *v) {
    fprintf(stderr, "stub_glColor3sv\n");
}

void glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
    fprintf(stderr, "stub_glColor3ub\n");
}

void glColor3ubv(const GLubyte *v) {
    fprintf(stderr, "stub_glColor3ubv\n");
}

void glColor3ui(GLuint red, GLuint green, GLuint blue) {
    fprintf(stderr, "stub_glColor3ui\n");
}

void glColor3uiv(const GLuint *v) {
    fprintf(stderr, "stub_glColor3uiv\n");
}

void glColor3us(GLushort red, GLushort green, GLushort blue) {
    fprintf(stderr, "stub_glColor3us\n");
}

void glColor3usv(const GLushort *v) {
    fprintf(stderr, "stub_glColor3usv\n");
}

void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
    fprintf(stderr, "stub_glColor4b\n");
}

void glColor4bv(const GLbyte *v) {
    fprintf(stderr, "stub_glColor4bv\n");
}

void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
    fprintf(stderr, "stub_glColor4d\n");
}

void glColor4dv(const GLdouble *v) {
    fprintf(stderr, "stub_glColor4dv\n");
}

void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    fprintf(stderr, "stub_glColor4f\n");
}

void glColor4fv(const GLfloat *v) {
    fprintf(stderr, "stub_glColor4fv\n");
}

void glColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
    fprintf(stderr, "stub_glColor4i\n");
}

void glColor4iv(const GLint *v) {
    fprintf(stderr, "stub_glColor4iv\n");
}

void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
    fprintf(stderr, "stub_glColor4s\n");
}

void glColor4sv(const GLshort *v) {
    fprintf(stderr, "stub_glColor4sv\n");
}

void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
    fprintf(stderr, "stub_glColor4ub\n");
}

void glColor4ubv(const GLubyte *v) {
    fprintf(stderr, "stub_glColor4ubv\n");
}

void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
    fprintf(stderr, "stub_glColor4ui\n");
}

void glColor4uiv(const GLuint *v) {
    fprintf(stderr, "stub_glColor4uiv\n");
}

void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
    fprintf(stderr, "stub_glColor4us\n");
}

void glColor4usv(const GLushort *v) {
    fprintf(stderr, "stub_glColor4usv\n");
}

void glEdgeFlag(GLboolean flag) {
    fprintf(stderr, "stub_glEdgeFlag\n");
}

void glEdgeFlagv(const GLboolean *flag) {
    fprintf(stderr, "stub_glEdgeFlagv\n");
}

void glEnd(void) {
    fprintf(stderr, "stub_glEnd\n");
}

void glIndexd(GLdouble c) {
    fprintf(stderr, "stub_glIndexd\n");
}

void glIndexdv(const GLdouble *c) {
    fprintf(stderr, "stub_glIndexdv\n");
}

void glIndexf(GLfloat c) {
    fprintf(stderr, "stub_glIndexf\n");
}

void glIndexfv(const GLfloat *c) {
    fprintf(stderr, "stub_glIndexfv\n");
}

void glIndexi(GLint c) {
    fprintf(stderr, "stub_glIndexi\n");
}

void glIndexiv(const GLint *c) {
    fprintf(stderr, "stub_glIndexiv\n");
}

void glIndexs(GLshort c) {
    fprintf(stderr, "stub_glIndexs\n");
}

void glIndexsv(const GLshort *c) {
    fprintf(stderr, "stub_glIndexsv\n");
}

void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
    fprintf(stderr, "stub_glNormal3b\n");
}

void glNormal3bv(const GLbyte *v) {
    fprintf(stderr, "stub_glNormal3bv\n");
}

void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
    fprintf(stderr, "stub_glNormal3d\n");
}

void glNormal3dv(const GLdouble *v) {
    fprintf(stderr, "stub_glNormal3dv\n");
}

void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
    fprintf(stderr, "stub_glNormal3f\n");
}

void glNormal3fv(const GLfloat *v) {
    fprintf(stderr, "stub_glNormal3fv\n");
}

void glNormal3i(GLint nx, GLint ny, GLint nz) {
    fprintf(stderr, "stub_glNormal3i\n");
}

void glNormal3iv(const GLint *v) {
    fprintf(stderr, "stub_glNormal3iv\n");
}

void glNormal3s(GLshort nx, GLshort ny, GLshort nz) {
    fprintf(stderr, "stub_glNormal3s\n");
}

void glNormal3sv(const GLshort *v) {
    fprintf(stderr, "stub_glNormal3sv\n");
}

void glRasterPos2d(GLdouble x, GLdouble y) {
    fprintf(stderr, "stub_glRasterPos2d\n");
}

void glRasterPos2dv(const GLdouble *v) {
    fprintf(stderr, "stub_glRasterPos2dv\n");
}

void glRasterPos2f(GLfloat x, GLfloat y) {
    fprintf(stderr, "stub_glRasterPos2f\n");
}

void glRasterPos2fv(const GLfloat *v) {
    fprintf(stderr, "stub_glRasterPos2fv\n");
}

void glRasterPos2i(GLint x, GLint y) {
    fprintf(stderr, "stub_glRasterPos2i\n");
}

void glRasterPos2iv(const GLint *v) {
    fprintf(stderr, "stub_glRasterPos2iv\n");
}

void glRasterPos2s(GLshort x, GLshort y) {
    fprintf(stderr, "stub_glRasterPos2s\n");
}

void glRasterPos2sv(const GLshort *v) {
    fprintf(stderr, "stub_glRasterPos2sv\n");
}

void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {
    fprintf(stderr, "stub_glRasterPos3d\n");
}

void glRasterPos3dv(const GLdouble *v) {
    fprintf(stderr, "stub_glRasterPos3dv\n");
}

void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {
    fprintf(stderr, "stub_glRasterPos3f\n");
}

void glRasterPos3fv(const GLfloat *v) {
    fprintf(stderr, "stub_glRasterPos3fv\n");
}

void glRasterPos3i(GLint x, GLint y, GLint z) {
    fprintf(stderr, "stub_glRasterPos3i\n");
}

void glRasterPos3iv(const GLint *v) {
    fprintf(stderr, "stub_glRasterPos3iv\n");
}

void glRasterPos3s(GLshort x, GLshort y, GLshort z) {
    fprintf(stderr, "stub_glRasterPos3s\n");
}

void glRasterPos3sv(const GLshort *v) {
    fprintf(stderr, "stub_glRasterPos3sv\n");
}

void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
    fprintf(stderr, "stub_glRasterPos4d\n");
}

void glRasterPos4dv(const GLdouble *v) {
    fprintf(stderr, "stub_glRasterPos4dv\n");
}

void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    fprintf(stderr, "stub_glRasterPos4f\n");
}

void glRasterPos4fv(const GLfloat *v) {
    fprintf(stderr, "stub_glRasterPos4fv\n");
}

void glRasterPos4i(GLint x, GLint y, GLint z, GLint w) {
    fprintf(stderr, "stub_glRasterPos4i\n");
}

void glRasterPos4iv(const GLint *v) {
    fprintf(stderr, "stub_glRasterPos4iv\n");
}

void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {
    fprintf(stderr, "stub_glRasterPos4s\n");
}

void glRasterPos4sv(const GLshort *v) {
    fprintf(stderr, "stub_glRasterPos4sv\n");
}

void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
    fprintf(stderr, "stub_glRectd\n");
}

void glRectdv(const GLdouble *v1, const GLdouble *v2) {
    fprintf(stderr, "stub_glRectdv\n");
}

void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
    fprintf(stderr, "stub_glRectf\n");
}

void glRectfv(const GLfloat *v1, const GLfloat *v2) {
    fprintf(stderr, "stub_glRectfv\n");
}

void glRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
    fprintf(stderr, "stub_glRecti\n");
}

void glRectiv(const GLint *v1, const GLint *v2) {
    fprintf(stderr, "stub_glRectiv\n");
}

void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
    fprintf(stderr, "stub_glRects\n");
}

void glRectsv(const GLshort *v1, const GLshort *v2) {
    fprintf(stderr, "stub_glRectsv\n");
}

void glTexCoord1d(GLdouble s) {
    fprintf(stderr, "stub_glTexCoord1d\n");
}

void glTexCoord1dv(const GLdouble *v) {
    fprintf(stderr, "stub_glTexCoord1dv\n");
}

void glTexCoord1f(GLfloat s) {
    fprintf(stderr, "stub_glTexCoord1f\n");
}

void glTexCoord1fv(const GLfloat *v) {
    fprintf(stderr, "stub_glTexCoord1fv\n");
}

void glTexCoord1i(GLint s) {
    fprintf(stderr, "stub_glTexCoord1i\n");
}

void glTexCoord1iv(const GLint *v) {
    fprintf(stderr, "stub_glTexCoord1iv\n");
}

void glTexCoord1s(GLshort s) {
    fprintf(stderr, "stub_glTexCoord1s\n");
}

void glTexCoord1sv(const GLshort *v) {
    fprintf(stderr, "stub_glTexCoord1sv\n");
}

void glTexCoord2d(GLdouble s, GLdouble t) {
    fprintf(stderr, "stub_glTexCoord2d\n");
}

void glTexCoord2dv(const GLdouble *v) {
    fprintf(stderr, "stub_glTexCoord2dv\n");
}

void glTexCoord2f(GLfloat s, GLfloat t) {
    fprintf(stderr, "stub_glTexCoord2f\n");
}

void glTexCoord2fv(const GLfloat *v) {
    fprintf(stderr, "stub_glTexCoord2fv\n");
}

void glTexCoord2i(GLint s, GLint t) {
    fprintf(stderr, "stub_glTexCoord2i\n");
}

void glTexCoord2iv(const GLint *v) {
    fprintf(stderr, "stub_glTexCoord2iv\n");
}

void glTexCoord2s(GLshort s, GLshort t) {
    fprintf(stderr, "stub_glTexCoord2s\n");
}

void glTexCoord2sv(const GLshort *v) {
    fprintf(stderr, "stub_glTexCoord2sv\n");
}

void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
    fprintf(stderr, "stub_glTexCoord3d\n");
}

void glTexCoord3dv(const GLdouble *v) {
    fprintf(stderr, "stub_glTexCoord3dv\n");
}

void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
    fprintf(stderr, "stub_glTexCoord3f\n");
}

void glTexCoord3fv(const GLfloat *v) {
    fprintf(stderr, "stub_glTexCoord3fv\n");
}

void glTexCoord3i(GLint s, GLint t, GLint r) {
    fprintf(stderr, "stub_glTexCoord3i\n");
}

void glTexCoord3iv(const GLint *v) {
    fprintf(stderr, "stub_glTexCoord3iv\n");
}

void glTexCoord3s(GLshort s, GLshort t, GLshort r) {
    fprintf(stderr, "stub_glTexCoord3s\n");
}

void glTexCoord3sv(const GLshort *v) {
    fprintf(stderr, "stub_glTexCoord3sv\n");
}

void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
    fprintf(stderr, "stub_glTexCoord4d\n");
}

void glTexCoord4dv(const GLdouble *v) {
    fprintf(stderr, "stub_glTexCoord4dv\n");
}

void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
    fprintf(stderr, "stub_glTexCoord4f\n");
}

void glTexCoord4fv(const GLfloat *v) {
    fprintf(stderr, "stub_glTexCoord4fv\n");
}

void glTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
    fprintf(stderr, "stub_glTexCoord4i\n");
}

void glTexCoord4iv(const GLint *v) {
    fprintf(stderr, "stub_glTexCoord4iv\n");
}

void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
    fprintf(stderr, "stub_glTexCoord4s\n");
}

void glTexCoord4sv(const GLshort *v) {
    fprintf(stderr, "stub_glTexCoord4sv\n");
}

void glVertex2d(GLdouble x, GLdouble y) {
    fprintf(stderr, "stub_glVertex2d\n");
}

void glVertex2dv(const GLdouble *v) {
    fprintf(stderr, "stub_glVertex2dv\n");
}

void glVertex2f(GLfloat x, GLfloat y) {
    fprintf(stderr, "stub_glVertex2f\n");
}

void glVertex2fv(const GLfloat *v) {
    fprintf(stderr, "stub_glVertex2fv\n");
}

void glVertex2i(GLint x, GLint y) {
    fprintf(stderr, "stub_glVertex2i\n");
}

void glVertex2iv(const GLint *v) {
    fprintf(stderr, "stub_glVertex2iv\n");
}

void glVertex2s(GLshort x, GLshort y) {
    fprintf(stderr, "stub_glVertex2s\n");
}

void glVertex2sv(const GLshort *v) {
    fprintf(stderr, "stub_glVertex2sv\n");
}

void glVertex3d(GLdouble x, GLdouble y, GLdouble z) {
    fprintf(stderr, "stub_glVertex3d\n");
}

void glVertex3dv(const GLdouble *v) {
    fprintf(stderr, "stub_glVertex3dv\n");
}

void glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
    fprintf(stderr, "stub_glVertex3f\n");
}

void glVertex3fv(const GLfloat *v) {
    fprintf(stderr, "stub_glVertex3fv\n");
}

void glVertex3i(GLint x, GLint y, GLint z) {
    fprintf(stderr, "stub_glVertex3i\n");
}

void glVertex3iv(const GLint *v) {
    fprintf(stderr, "stub_glVertex3iv\n");
}

void glVertex3s(GLshort x, GLshort y, GLshort z) {
    fprintf(stderr, "stub_glVertex3s\n");
}

void glVertex3sv(const GLshort *v) {
    fprintf(stderr, "stub_glVertex3sv\n");
}

void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
    fprintf(stderr, "stub_glVertex4d\n");
}

void glVertex4dv(const GLdouble *v) {
    fprintf(stderr, "stub_glVertex4dv\n");
}

void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    fprintf(stderr, "stub_glVertex4f\n");
}

void glVertex4fv(const GLfloat *v) {
    fprintf(stderr, "stub_glVertex4fv\n");
}

void glVertex4i(GLint x, GLint y, GLint z, GLint w) {
    fprintf(stderr, "stub_glVertex4i\n");
}

void glVertex4iv(const GLint *v) {
    fprintf(stderr, "stub_glVertex4iv\n");
}

void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
    fprintf(stderr, "stub_glVertex4s\n");
}

void glVertex4sv(const GLshort *v) {
    fprintf(stderr, "stub_glVertex4sv\n");
}

void glClipPlane(GLenum plane, const GLdouble *equation) {
    fprintf(stderr, "stub_glClipPlane\n");
}

void glColorMaterial(GLenum face, GLenum mode) {
    fprintf(stderr, "stub_glColorMaterial\n");
}

void glCullFace(GLenum mode) {
    fprintf(stderr, "stub_glCullFace\n");
}

void glFogf(GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glFogf\n");
}

void glFogfv(GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glFogfv\n");
}

void glFogi(GLenum pname, GLint param) {
    fprintf(stderr, "stub_glFogi\n");
}

void glFogiv(GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glFogiv\n");
}

void glFrontFace(GLenum mode) {
    fprintf(stderr, "stub_glFrontFace\n");
}

void glHint(GLenum target, GLenum mode) {
    fprintf(stderr, "stub_glHint\n");
}

void glLightf(GLenum light, GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glLightf\n");
}

void glLightfv(GLenum light, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glLightfv\n");
}

void glLighti(GLenum light, GLenum pname, GLint param) {
    fprintf(stderr, "stub_glLighti\n");
}

void glLightiv(GLenum light, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glLightiv\n");
}

void glLightModelf(GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glLightModelf\n");
}

void glLightModelfv(GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glLightModelfv\n");
}

void glLightModeli(GLenum pname, GLint param) {
    fprintf(stderr, "stub_glLightModeli\n");
}

void glLightModeliv(GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glLightModeliv\n");
}

void glLineStipple(GLint factor, GLushort pattern) {
    fprintf(stderr, "stub_glLineStipple\n");
}

void glLineWidth(GLfloat width) {
    fprintf(stderr, "stub_glLineWidth\n");
}

void glMaterialf(GLenum face, GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glMaterialf\n");
}

void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glMaterialfv\n");
}

void glMateriali(GLenum face, GLenum pname, GLint param) {
    fprintf(stderr, "stub_glMateriali\n");
}

void glMaterialiv(GLenum face, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glMaterialiv\n");
}

void glPointSize(GLfloat size) {
    fprintf(stderr, "stub_glPointSize\n");
}

void glPolygonMode(GLenum face, GLenum mode) {
    fprintf(stderr, "stub_glPolygonMode\n");
}

void glPolygonStipple(const GLubyte *mask) {
    fprintf(stderr, "stub_glPolygonStipple\n");
}

void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
    fprintf(stderr, "stub_glScissor\n");
}

void glShadeModel(GLenum mode) {
    fprintf(stderr, "stub_glShadeModel\n");
}

void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glTexParameterf\n");
}

void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glTexParameterfv\n");
}

void glTexParameteri(GLenum target, GLenum pname, GLint param) {
    fprintf(stderr, "stub_glTexParameteri\n");
}

void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glTexParameteriv\n");
}

void glTexImage1D(GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexImage1D\n");
}

void glTexImage2D(GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexImage2D\n");
}

void glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glTexEnvf\n");
}

void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glTexEnvfv\n");
}

void glTexEnvi(GLenum target, GLenum pname, GLint param) {
    fprintf(stderr, "stub_glTexEnvi\n");
}

void glTexEnviv(GLenum target, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glTexEnviv\n");
}

void glTexGend(GLenum coord, GLenum pname, GLdouble param) {
    fprintf(stderr, "stub_glTexGend\n");
}

void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
    fprintf(stderr, "stub_glTexGendv\n");
}

void glTexGenf(GLenum coord, GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glTexGenf\n");
}

void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glTexGenfv\n");
}

void glTexGeni(GLenum coord, GLenum pname, GLint param) {
    fprintf(stderr, "stub_glTexGeni\n");
}

void glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glTexGeniv\n");
}

void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {
    fprintf(stderr, "stub_glFeedbackBuffer\n");
}

void glSelectBuffer(GLsizei size, GLuint *buffer) {
    fprintf(stderr, "stub_glSelectBuffer\n");
}

GLint glRenderMode(GLenum mode) {
    fprintf(stderr, "stub_glRenderMode\n");
    return 0;
}

void glInitNames(void) {
    fprintf(stderr, "stub_glInitNames\n");
}

void glLoadName(GLuint name) {
    fprintf(stderr, "stub_glLoadName\n");
}

void glPassThrough(GLfloat token) {
    fprintf(stderr, "stub_glPassThrough\n");
}

void glPopName(void) {
    fprintf(stderr, "stub_glPopName\n");
}

void glPushName(GLuint name) {
    fprintf(stderr, "stub_glPushName\n");
}

void glDrawBuffer(GLenum mode) {
    fprintf(stderr, "stub_glDrawBuffer\n");
}

void glClear(GLbitfield mask) {
    fprintf(stderr, "stub_glClear\n");
}

void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    fprintf(stderr, "stub_glClearAccum\n");
}

void glClearIndex(GLfloat c) {
    fprintf(stderr, "stub_glClearIndex\n");
}

void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
    fprintf(stderr, "stub_glClearColor\n");
}

void glClearStencil(GLint s) {
    fprintf(stderr, "stub_glClearStencil\n");
}

void glClearDepth(GLclampd depth) {
    fprintf(stderr, "stub_glClearDepth\n");
}

void glStencilMask(GLuint mask) {
    fprintf(stderr, "stub_glStencilMask\n");
}

void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
    fprintf(stderr, "stub_glColorMask\n");
}

void glDepthMask(GLboolean flag) {
    fprintf(stderr, "stub_glDepthMask\n");
}

void glIndexMask(GLuint mask) {
    fprintf(stderr, "stub_glIndexMask\n");
}

void glAccum(GLenum op, GLfloat value) {
    fprintf(stderr, "stub_glAccum\n");
}

void glDisable(GLenum cap) {
    fprintf(stderr, "stub_glDisable\n");
}

void glEnable(GLenum cap) {
    fprintf(stderr, "stub_glEnable\n");
}

void glFinish(void) {
    fprintf(stderr, "stub_glFinish\n");
}

void glFlush(void) {
    fprintf(stderr, "stub_glFlush\n");
}

void glPopAttrib(void) {
    fprintf(stderr, "stub_glPopAttrib\n");
}

void glPushAttrib(GLbitfield mask) {
    fprintf(stderr, "stub_glPushAttrib\n");
}

void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) {
    fprintf(stderr, "stub_glMap1d\n");
}

void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {
    fprintf(stderr, "stub_glMap1f\n");
}

void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {
    fprintf(stderr, "stub_glMap2d\n");
}

void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {
    fprintf(stderr, "stub_glMap2f\n");
}

void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
    fprintf(stderr, "stub_glMapGrid1d\n");
}

void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {
    fprintf(stderr, "stub_glMapGrid1f\n");
}

void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {
    fprintf(stderr, "stub_glMapGrid2d\n");
}

void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {
    fprintf(stderr, "stub_glMapGrid2f\n");
}

void glEvalCoord1d(GLdouble u) {
    fprintf(stderr, "stub_glEvalCoord1d\n");
}

void glEvalCoord1dv(const GLdouble *u) {
    fprintf(stderr, "stub_glEvalCoord1dv\n");
}

void glEvalCoord1f(GLfloat u) {
    fprintf(stderr, "stub_glEvalCoord1f\n");
}

void glEvalCoord1fv(const GLfloat *u) {
    fprintf(stderr, "stub_glEvalCoord1fv\n");
}

void glEvalCoord2d(GLdouble u, GLdouble v) {
    fprintf(stderr, "stub_glEvalCoord2d\n");
}

void glEvalCoord2dv(const GLdouble *u) {
    fprintf(stderr, "stub_glEvalCoord2dv\n");
}

void glEvalCoord2f(GLfloat u, GLfloat v) {
    fprintf(stderr, "stub_glEvalCoord2f\n");
}

void glEvalCoord2fv(const GLfloat *u) {
    fprintf(stderr, "stub_glEvalCoord2fv\n");
}

void glEvalMesh1(GLenum mode, GLint i1, GLint i2) {
    fprintf(stderr, "stub_glEvalMesh1\n");
}

void glEvalPoint1(GLint i) {
    fprintf(stderr, "stub_glEvalPoint1\n");
}

void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {
    fprintf(stderr, "stub_glEvalMesh2\n");
}

void glEvalPoint2(GLint i, GLint j) {
    fprintf(stderr, "stub_glEvalPoint2\n");
}

void glAlphaFunc(GLenum func, GLclampf ref) {
    fprintf(stderr, "stub_glAlphaFunc\n");
}

void glBlendFunc(GLenum sfactor, GLenum dfactor) {
    fprintf(stderr, "stub_glBlendFunc\n");
}

void glLogicOp(GLenum opcode) {
    fprintf(stderr, "stub_glLogicOp\n");
}

void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
    fprintf(stderr, "stub_glStencilFunc\n");
}

void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
    fprintf(stderr, "stub_glStencilOp\n");
}

void glDepthFunc(GLenum func) {
    fprintf(stderr, "stub_glDepthFunc\n");
}

void glPixelZoom(GLfloat xfactor, GLfloat yfactor) {
    fprintf(stderr, "stub_glPixelZoom\n");
}

void glPixelTransferf(GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glPixelTransferf\n");
}

void glPixelTransferi(GLenum pname, GLint param) {
    fprintf(stderr, "stub_glPixelTransferi\n");
}

void glPixelStoref(GLenum pname, GLfloat param) {
    fprintf(stderr, "stub_glPixelStoref\n");
}

void glPixelStorei(GLenum pname, GLint param) {
    fprintf(stderr, "stub_glPixelStorei\n");
}

void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values) {
    fprintf(stderr, "stub_glPixelMapfv\n");
}

void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values) {
    fprintf(stderr, "stub_glPixelMapuiv\n");
}

void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values) {
    fprintf(stderr, "stub_glPixelMapusv\n");
}

void glReadBuffer(GLenum mode) {
    fprintf(stderr, "stub_glReadBuffer\n");
}

void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {
    fprintf(stderr, "stub_glCopyPixels\n");
}

void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {
    fprintf(stderr, "stub_glReadPixels\n");
}

void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glDrawPixels\n");
}

void glGetBooleanv(GLenum pname, GLboolean *params) {
    fprintf(stderr, "stub_glGetBooleanv\n");
}

void glGetClipPlane(GLenum plane, GLdouble *equation) {
    fprintf(stderr, "stub_glGetClipPlane\n");
}

void glGetDoublev(GLenum pname, GLdouble *params) {
    fprintf(stderr, "stub_glGetDoublev\n");
}

GLenum glGetError(void) {
    fprintf(stderr, "stub_glGetError\n");
    return 0;
}

void glGetFloatv(GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetFloatv\n");
}

void glGetIntegerv(GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetIntegerv\n");
}

void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetLightfv\n");
}

void glGetLightiv(GLenum light, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetLightiv\n");
}

void glGetMapdv(GLenum target, GLenum query, GLdouble *v) {
    fprintf(stderr, "stub_glGetMapdv\n");
}

void glGetMapfv(GLenum target, GLenum query, GLfloat *v) {
    fprintf(stderr, "stub_glGetMapfv\n");
}

void glGetMapiv(GLenum target, GLenum query, GLint *v) {
    fprintf(stderr, "stub_glGetMapiv\n");
}

void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetMaterialfv\n");
}

void glGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetMaterialiv\n");
}

void glGetPixelMapfv(GLenum map, GLfloat *values) {
    fprintf(stderr, "stub_glGetPixelMapfv\n");
}

void glGetPixelMapuiv(GLenum map, GLuint *values) {
    fprintf(stderr, "stub_glGetPixelMapuiv\n");
}

void glGetPixelMapusv(GLenum map, GLushort *values) {
    fprintf(stderr, "stub_glGetPixelMapusv\n");
}

void glGetPolygonStipple(GLubyte *mask) {
    fprintf(stderr, "stub_glGetPolygonStipple\n");
}

const GLubyte * glGetString(GLenum name) {
    fprintf(stderr, "stub_glGetString\n");
    return 0;
}

void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetTexEnvfv\n");
}

void glGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetTexEnviv\n");
}

void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
    fprintf(stderr, "stub_glGetTexGendv\n");
}

void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetTexGenfv\n");
}

void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetTexGeniv\n");
}

void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {
    fprintf(stderr, "stub_glGetTexImage\n");
}

void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetTexParameterfv\n");
}

void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetTexParameteriv\n");
}

void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetTexLevelParameterfv\n");
}

void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetTexLevelParameteriv\n");
}

GLboolean glIsEnabled(GLenum cap) {
    fprintf(stderr, "stub_glIsEnabled\n");
    return 0;
}

GLboolean glIsList(GLuint list) {
    fprintf(stderr, "stub_glIsList\n");
    return 0;
}

void glDepthRange(GLclampd zNear, GLclampd zFar) {
    fprintf(stderr, "stub_glDepthRange\n");
}

void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
    fprintf(stderr, "stub_glFrustum\n");
}

void glLoadIdentity(void) {
    fprintf(stderr, "stub_glLoadIdentity\n");
}

void glLoadMatrixf(const GLfloat *m) {
    fprintf(stderr, "stub_glLoadMatrixf\n");
}

void glLoadMatrixd(const GLdouble *m) {
    fprintf(stderr, "stub_glLoadMatrixd\n");
}

void glMatrixMode(GLenum mode) {
    fprintf(stderr, "stub_glMatrixMode\n");
}

void glMultMatrixf(const GLfloat *m) {
    fprintf(stderr, "stub_glMultMatrixf\n");
}

void glMultMatrixd(const GLdouble *m) {
    fprintf(stderr, "stub_glMultMatrixd\n");
}

void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
    fprintf(stderr, "stub_glOrtho\n");
}

void glPopMatrix(void) {
    fprintf(stderr, "stub_glPopMatrix\n");
}

void glPushMatrix(void) {
    fprintf(stderr, "stub_glPushMatrix\n");
}

void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
    fprintf(stderr, "stub_glRotated\n");
}

void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
    fprintf(stderr, "stub_glRotatef\n");
}

void glScaled(GLdouble x, GLdouble y, GLdouble z) {
    fprintf(stderr, "stub_glScaled\n");
}

void glScalef(GLfloat x, GLfloat y, GLfloat z) {
    fprintf(stderr, "stub_glScalef\n");
}

void glTranslated(GLdouble x, GLdouble y, GLdouble z) {
    fprintf(stderr, "stub_glTranslated\n");
}

void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
    fprintf(stderr, "stub_glTranslatef\n");
}

void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
    fprintf(stderr, "stub_glViewport\n");
}

void glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
    fprintf(stderr, "stub_glBlendColorEXT\n");
}

void glBlendEquationEXT(GLenum mode) {
    fprintf(stderr, "stub_glBlendEquationEXT\n");
}

void glPolygonOffsetEXT(GLfloat factor, GLfloat bias) {
    fprintf(stderr, "stub_glPolygonOffsetEXT\n");
}

void glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexSubImage1DEXT\n");
}

void glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexSubImage2DEXT\n");
}

void glSampleMaskSGIS(GLclampf value, GLboolean invert) {
    fprintf(stderr, "stub_glSampleMaskSGIS\n");
}

void glSamplePatternSGIS(GLenum pattern) {
    fprintf(stderr, "stub_glSamplePatternSGIS\n");
}

void glTagSampleBufferSGIX(void) {
    fprintf(stderr, "stub_glTagSampleBufferSGIX\n");
}

void glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) {
    fprintf(stderr, "stub_glConvolutionFilter1DEXT\n");
}

void glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) {
    fprintf(stderr, "stub_glConvolutionFilter2DEXT\n");
}

void glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params) {
    fprintf(stderr, "stub_glConvolutionParameterfEXT\n");
}

void glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glConvolutionParameterfvEXT\n");
}

void glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params) {
    fprintf(stderr, "stub_glConvolutionParameteriEXT\n");
}

void glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glConvolutionParameterivEXT\n");
}

void glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
    fprintf(stderr, "stub_glCopyConvolutionFilter1DEXT\n");
}

void glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {
    fprintf(stderr, "stub_glCopyConvolutionFilter2DEXT\n");
}

void glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *image) {
    fprintf(stderr, "stub_glGetConvolutionFilterEXT\n");
}

void glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetConvolutionParameterfvEXT\n");
}

void glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetConvolutionParameterivEXT\n");
}

void glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) {
    fprintf(stderr, "stub_glGetSeparableFilterEXT\n");
}

void glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) {
    fprintf(stderr, "stub_glSeparableFilter2DEXT\n");
}

void glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
    fprintf(stderr, "stub_glGetHistogramEXT\n");
}

void glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetHistogramParameterfvEXT\n");
}

void glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetHistogramParameterivEXT\n");
}

void glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
    fprintf(stderr, "stub_glGetMinmaxEXT\n");
}

void glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetMinmaxParameterfvEXT\n");
}

void glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetMinmaxParameterivEXT\n");
}

void glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) {
    fprintf(stderr, "stub_glHistogramEXT\n");
}

void glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink) {
    fprintf(stderr, "stub_glMinmaxEXT\n");
}

void glResetHistogramEXT(GLenum target) {
    fprintf(stderr, "stub_glResetHistogramEXT\n");
}

void glResetMinmaxEXT(GLenum target) {
    fprintf(stderr, "stub_glResetMinmaxEXT\n");
}

void glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexImage3DEXT\n");
}

void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexSubImage3DEXT\n");
}

void glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points) {
    fprintf(stderr, "stub_glDetailTexFuncSGIS\n");
}

void glGetDetailTexFuncSGIS(GLenum target, GLfloat *points) {
    fprintf(stderr, "stub_glGetDetailTexFuncSGIS\n");
}

void glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points) {
    fprintf(stderr, "stub_glSharpenTexFuncSGIS\n");
}

void glGetSharpenTexFuncSGIS(GLenum target, GLfloat *points) {
    fprintf(stderr, "stub_glGetSharpenTexFuncSGIS\n");
}

void glArrayElementEXT(GLint i) {
    fprintf(stderr, "stub_glArrayElementEXT\n");
}

void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
    fprintf(stderr, "stub_glColorPointerEXT\n");
}

void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) {
    fprintf(stderr, "stub_glDrawArraysEXT\n");
}

void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer) {
    fprintf(stderr, "stub_glEdgeFlagPointerEXT\n");
}

void glGetPointervEXT(GLenum pname, GLvoid* *params) {
    fprintf(stderr, "stub_glGetPointervEXT\n");
}

void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
    fprintf(stderr, "stub_glIndexPointerEXT\n");
}

void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
    fprintf(stderr, "stub_glNormalPointerEXT\n");
}

void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
    fprintf(stderr, "stub_glTexCoordPointerEXT\n");
}

void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
    fprintf(stderr, "stub_glVertexPointerEXT\n");
}

GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences) {
    fprintf(stderr, "stub_glAreTexturesResidentEXT\n");
    return 0;
}

void glBindTextureEXT(GLenum target, GLuint texture) {
    fprintf(stderr, "stub_glBindTextureEXT\n");
}

void glDeleteTexturesEXT(GLsizei n, const GLuint *textures) {
    fprintf(stderr, "stub_glDeleteTexturesEXT\n");
}

void glGenTexturesEXT(GLsizei n, GLuint *textures) {
    fprintf(stderr, "stub_glGenTexturesEXT\n");
}

GLboolean glIsTextureEXT(GLuint texture) {
    fprintf(stderr, "stub_glIsTextureEXT\n");
    return 0;
}

void glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
    fprintf(stderr, "stub_glPrioritizeTexturesEXT\n");
}

void glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) {
    fprintf(stderr, "stub_glColorTableSGI\n");
}

void glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glColorTableParameterfvSGI\n");
}

void glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glColorTableParameterivSGI\n");
}

void glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
    fprintf(stderr, "stub_glCopyColorTableSGI\n");
}

void glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid *table) {
    fprintf(stderr, "stub_glGetColorTableSGI\n");
}

void glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetColorTableParameterfvSGI\n");
}

void glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetColorTableParameterivSGI\n");
}

void glGetTexColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params) {
    fprintf(stderr, "stub_glGetTexColorTableParameterfvSGI\n");
}

void glGetTexColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params) {
    fprintf(stderr, "stub_glGetTexColorTableParameterivSGI\n");
}

void glTexColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params) {
    fprintf(stderr, "stub_glTexColorTableParameterfvSGI\n");
}

void glTexColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params) {
    fprintf(stderr, "stub_glTexColorTableParameterivSGI\n");
}

void glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
    fprintf(stderr, "stub_glCopyTexImage1DEXT\n");
}

void glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
    fprintf(stderr, "stub_glCopyTexImage2DEXT\n");
}

void glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
    fprintf(stderr, "stub_glCopyTexSubImage1DEXT\n");
}

void glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    fprintf(stderr, "stub_glCopyTexSubImage2DEXT\n");
}

void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    fprintf(stderr, "stub_glCopyTexSubImage3DEXT\n");
}

void glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexImage4DSGIS\n");
}

void glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels) {
    fprintf(stderr, "stub_glTexSubImage4DSGIS\n");
}

void glPixelTexGenSGIX(GLenum mode) {
    fprintf(stderr, "stub_glPixelTexGenSGIX\n");
}