/* Generated by call-gen.pl from /usr/local/include/GL/glext.h */

void OSMesaDriver::nfglBlendColor (GLclampf a, GLclampf b, GLclampf c, GLclampf d)
{
	D(bug("nfosmesa: glBlendColor"));
	fn.glBlendColor ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBlendEquation (GLenum a)
{
	D(bug("nfosmesa: glBlendEquation"));
	fn.glBlendEquation ( a);
}

void OSMesaDriver::nfglDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
{
	D(bug("nfosmesa: glDrawRangeElements"));
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	{
		int i;
		Uint32 *ptr32,i32;
		Uint16 *ptr16,i16;
		Uint8 *ptr8;

		ptr32 = (Uint32 *)indices;
		ptr16 = (Uint16 *)indices;
		ptr8 = (Uint8 *)indices;
		fn.glBegin(	mode);
		for (i=0;i<count;i++) {
			switch(type) {
				case GL_UNSIGNED_BYTE:
					if ((ptr8[i]>=start) && (ptr8[i]<=end)) {
						nfglArrayElement(ctx,ptr8[i]);
					}
					break;
				case GL_UNSIGNED_SHORT:
					i16=SDL_SwapBE16(ptr16[i]);
					if ((i16>=start) && (i16<=end)) {
						nfglArrayElement(ctx,i16);
					}
					break;
				case GL_UNSIGNED_INT:
					i32=SDL_SwapBE32(ptr32[i]);
					if ((i32>=start) && (i32<=end)) {
						nfglArrayElement(ctx,i32);
					}
					break;
			}
		}
		fn.glEnd();
	}
#else
	fn.glDrawRangeElements ( mode, start, end, count, type, indices);
#endif
}

void OSMesaDriver::nfglColorTable (GLenum a, GLenum b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glColorTable"));
	fn.glColorTable ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglColorTableParameterfv (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glColorTableParameterfv"));
	fn.glColorTableParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglColorTableParameteriv (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glColorTableParameteriv"));
	fn.glColorTableParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglCopyColorTable (GLenum a, GLenum b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyColorTable"));
	fn.glCopyColorTable ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetColorTable (GLenum a, GLenum b, GLenum c, GLvoid * d)
{
	D(bug("nfosmesa: glGetColorTable"));
	fn.glGetColorTable ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetColorTableParameterfv (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetColorTableParameterfv"));
	fn.glGetColorTableParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglGetColorTableParameteriv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetColorTableParameteriv"));
	fn.glGetColorTableParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglColorSubTable (GLenum a, GLsizei b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glColorSubTable"));
	fn.glColorSubTable ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglCopyColorSubTable (GLenum a, GLsizei b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyColorSubTable"));
	fn.glCopyColorSubTable ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglConvolutionFilter1D (GLenum a, GLenum b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glConvolutionFilter1D"));
	fn.glConvolutionFilter1D ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglConvolutionFilter2D (GLenum a, GLenum b, GLsizei c, GLsizei d, GLenum e, GLenum f, const GLvoid * g)
{
	D(bug("nfosmesa: glConvolutionFilter2D"));
	fn.glConvolutionFilter2D ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglConvolutionParameterf (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glConvolutionParameterf"));
	fn.glConvolutionParameterf ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameterfv (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glConvolutionParameterfv"));
	fn.glConvolutionParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameteri (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glConvolutionParameteri"));
	fn.glConvolutionParameteri ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameteriv (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glConvolutionParameteriv"));
	fn.glConvolutionParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglCopyConvolutionFilter1D (GLenum a, GLenum b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyConvolutionFilter1D"));
	fn.glCopyConvolutionFilter1D ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglCopyConvolutionFilter2D (GLenum a, GLenum b, GLint c, GLint d, GLsizei e, GLsizei f)
{
	D(bug("nfosmesa: glCopyConvolutionFilter2D"));
	fn.glCopyConvolutionFilter2D ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglGetConvolutionFilter (GLenum a, GLenum b, GLenum c, GLvoid * d)
{
	D(bug("nfosmesa: glGetConvolutionFilter"));
	fn.glGetConvolutionFilter ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetConvolutionParameterfv (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetConvolutionParameterfv"));
	fn.glGetConvolutionParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglGetConvolutionParameteriv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetConvolutionParameteriv"));
	fn.glGetConvolutionParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglGetSeparableFilter (GLenum a, GLenum b, GLenum c, GLvoid * d, GLvoid * e, GLvoid * f)
{
	D(bug("nfosmesa: glGetSeparableFilter"));
	fn.glGetSeparableFilter ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglSeparableFilter2D (GLenum a, GLenum b, GLsizei c, GLsizei d, GLenum e, GLenum f, const GLvoid * g, const GLvoid * h)
{
	D(bug("nfosmesa: glSeparableFilter2D"));
	fn.glSeparableFilter2D ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglGetHistogram (GLenum a, GLboolean b, GLenum c, GLenum d, GLvoid * e)
{
	D(bug("nfosmesa: glGetHistogram"));
	fn.glGetHistogram ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetHistogramParameterfv (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetHistogramParameterfv"));
	fn.glGetHistogramParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglGetHistogramParameteriv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetHistogramParameteriv"));
	fn.glGetHistogramParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglGetMinmax (GLenum a, GLboolean b, GLenum c, GLenum d, GLvoid * e)
{
	D(bug("nfosmesa: glGetMinmax"));
	fn.glGetMinmax ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetMinmaxParameterfv (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetMinmaxParameterfv"));
	fn.glGetMinmaxParameterfv ( a,  b,  c);
}

void OSMesaDriver::nfglGetMinmaxParameteriv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetMinmaxParameteriv"));
	fn.glGetMinmaxParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglHistogram (GLenum a, GLsizei b, GLenum c, GLboolean d)
{
	D(bug("nfosmesa: glHistogram"));
	fn.glHistogram ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMinmax (GLenum a, GLenum b, GLboolean c)
{
	D(bug("nfosmesa: glMinmax"));
	fn.glMinmax ( a,  b,  c);
}

void OSMesaDriver::nfglResetHistogram (GLenum a)
{
	D(bug("nfosmesa: glResetHistogram"));
	fn.glResetHistogram ( a);
}

void OSMesaDriver::nfglResetMinmax (GLenum a)
{
	D(bug("nfosmesa: glResetMinmax"));
	fn.glResetMinmax ( a);
}

void OSMesaDriver::nfglTexImage3D (GLenum a, GLint b, GLint c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLenum h, GLenum i, const GLvoid * j)
{
	D(bug("nfosmesa: glTexImage3D"));
	fn.glTexImage3D ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j);
}

void OSMesaDriver::nfglTexSubImage3D (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLenum j, const GLvoid * k)
{
	D(bug("nfosmesa: glTexSubImage3D"));
	fn.glTexSubImage3D ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglCopyTexSubImage3D (GLenum a, GLint b, GLint c, GLint d, GLint e, GLint f, GLint g, GLsizei h, GLsizei i)
{
	D(bug("nfosmesa: glCopyTexSubImage3D"));
	fn.glCopyTexSubImage3D ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglActiveTexture (GLenum a)
{
	D(bug("nfosmesa: glActiveTexture"));
	fn.glActiveTexture ( a);
}

void OSMesaDriver::nfglClientActiveTexture (GLenum a)
{
	D(bug("nfosmesa: glClientActiveTexture"));
	fn.glClientActiveTexture ( a);
}

void OSMesaDriver::nfglMultiTexCoord1d (GLenum a, GLdouble b)
{
	D(bug("nfosmesa: glMultiTexCoord1d"));
	fn.glMultiTexCoord1d ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1dv (GLenum a, const GLdouble * b)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1dv"));
	Atari2HostDoublePtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1dv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord1f (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glMultiTexCoord1f"));
	fn.glMultiTexCoord1f ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1fv (GLenum a, const GLfloat * b)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1fv"));
	Atari2HostFloatPtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1fv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord1i (GLenum a, GLint b)
{
	D(bug("nfosmesa: glMultiTexCoord1i"));
	fn.glMultiTexCoord1i ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1iv (GLenum a, const GLint * b)
{
	GLint tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1iv"));
	Atari2HostIntPtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1iv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord1s (GLenum a, GLshort b)
{
	D(bug("nfosmesa: glMultiTexCoord1s"));
	fn.glMultiTexCoord1s ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1sv (GLenum a, const GLshort * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1sv"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glMultiTexCoord1sv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2d (GLenum a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glMultiTexCoord2d"));
	fn.glMultiTexCoord2d ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2dv (GLenum a, const GLdouble * b)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2dv"));
	Atari2HostDoublePtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2dv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2f (GLenum a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glMultiTexCoord2f"));
	fn.glMultiTexCoord2f ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2fv (GLenum a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2fv"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2fv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2i (GLenum a, GLint b, GLint c)
{
	D(bug("nfosmesa: glMultiTexCoord2i"));
	fn.glMultiTexCoord2i ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2iv (GLenum a, const GLint * b)
{
	GLint tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2iv"));
	Atari2HostIntPtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2iv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2s (GLenum a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glMultiTexCoord2s"));
	fn.glMultiTexCoord2s ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2sv (GLenum a, const GLshort * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2sv"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glMultiTexCoord2sv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3d (GLenum a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glMultiTexCoord3d"));
	fn.glMultiTexCoord3d ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3dv (GLenum a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3dv"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3dv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3f (GLenum a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glMultiTexCoord3f"));
	fn.glMultiTexCoord3f ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3fv (GLenum a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3fv"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3fv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3i (GLenum a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glMultiTexCoord3i"));
	fn.glMultiTexCoord3i ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3iv (GLenum a, const GLint * b)
{
	GLint tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3iv"));
	Atari2HostIntPtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3iv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3s (GLenum a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glMultiTexCoord3s"));
	fn.glMultiTexCoord3s ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3sv (GLenum a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3sv"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glMultiTexCoord3sv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4d (GLenum a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{
	D(bug("nfosmesa: glMultiTexCoord4d"));
	fn.glMultiTexCoord4d ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4dv (GLenum a, const GLdouble * b)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4dv"));
	Atari2HostDoublePtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4dv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4f (GLenum a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glMultiTexCoord4f"));
	fn.glMultiTexCoord4f ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4fv (GLenum a, const GLfloat * b)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4fv"));
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4fv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4i (GLenum a, GLint b, GLint c, GLint d, GLint e)
{
	D(bug("nfosmesa: glMultiTexCoord4i"));
	fn.glMultiTexCoord4i ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4iv (GLenum a, const GLint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4iv"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4iv ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4s (GLenum a, GLshort b, GLshort c, GLshort d, GLshort e)
{
	D(bug("nfosmesa: glMultiTexCoord4s"));
	fn.glMultiTexCoord4s ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4sv (GLenum a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4sv"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glMultiTexCoord4sv ( a, tmp);
}

void OSMesaDriver::nfglLoadTransposeMatrixf (const GLfloat * a)
{
	GLfloat tmp[16];

	D(bug("nfosmesa: glLoadTransposeMatrixf"));
	Atari2HostFloatPtr(16, (Uint32 *)a, tmp);
	fn.glLoadTransposeMatrixf ( tmp);
}

void OSMesaDriver::nfglLoadTransposeMatrixd (const GLdouble * a)
{
	GLdouble tmp[16];

	D(bug("nfosmesa: glLoadTransposeMatrixd"));
	Atari2HostDoublePtr(16, (Uint32 *)a, tmp);
	fn.glLoadTransposeMatrixd (tmp);
}

void OSMesaDriver::nfglMultTransposeMatrixf (const GLfloat * a)
{
	GLfloat tmp[16];

	D(bug("nfosmesa: glMultTransposeMatrixf"));
	Atari2HostFloatPtr(16, (Uint32 *)a, tmp);
	fn.glMultTransposeMatrixf (tmp);
}

void OSMesaDriver::nfglMultTransposeMatrixd (const GLdouble * a)
{
	GLdouble tmp[16];

	D(bug("nfosmesa: glMultTransposeMatrixd"));
	Atari2HostDoublePtr(16, (Uint32 *)a, tmp);
	fn.glMultTransposeMatrixd (tmp);
}

void OSMesaDriver::nfglSampleCoverage (GLclampf a, GLboolean b)
{
	D(bug("nfosmesa: glSampleCoverage"));
	fn.glSampleCoverage ( a,  b);
}

void OSMesaDriver::nfglCompressedTexImage3D (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLsizei h, const GLvoid * i)
{
	D(bug("nfosmesa: glCompressedTexImage3D"));
	fn.glCompressedTexImage3D ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglCompressedTexImage2D (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLint f, GLsizei g, const GLvoid * h)
{
	D(bug("nfosmesa: glCompressedTexImage2D"));
	fn.glCompressedTexImage2D ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglCompressedTexImage1D (GLenum a, GLint b, GLenum c, GLsizei d, GLint e, GLsizei f, const GLvoid * g)
{
	D(bug("nfosmesa: glCompressedTexImage1D"));
	fn.glCompressedTexImage1D ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglCompressedTexSubImage3D (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLsizei j, const GLvoid * k)
{
	D(bug("nfosmesa: glCompressedTexSubImage3D"));
	fn.glCompressedTexSubImage3D ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglCompressedTexSubImage2D (GLenum a, GLint b, GLint c, GLint d, GLsizei e, GLsizei f, GLenum g, GLsizei h, const GLvoid * i)
{
	D(bug("nfosmesa: glCompressedTexSubImage2D"));
	fn.glCompressedTexSubImage2D ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglCompressedTexSubImage1D (GLenum a, GLint b, GLint c, GLsizei d, GLenum e, GLsizei f, const GLvoid * g)
{
	D(bug("nfosmesa: glCompressedTexSubImage1D"));
	fn.glCompressedTexSubImage1D ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglGetCompressedTexImage (GLenum a, GLint b, GLvoid * c)
{
	D(bug("nfosmesa: glGetCompressedTexImage"));
	fn.glGetCompressedTexImage ( a,  b,  c);
}

void OSMesaDriver::nfglBlendFuncSeparate (GLenum a, GLenum b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glBlendFuncSeparate"));
	fn.glBlendFuncSeparate ( a,  b,  c,  d);
}

void OSMesaDriver::nfglFogCoordf (GLfloat a)
{
	D(bug("nfosmesa: glFogCoordf"));
	fn.glFogCoordf ( a);
}

void OSMesaDriver::nfglFogCoordfv (const GLfloat * a)
{
	D(bug("nfosmesa: glFogCoordfv"));
	fn.glFogCoordfv ( a);
}

void OSMesaDriver::nfglFogCoordd (GLdouble a)
{
	D(bug("nfosmesa: glFogCoordd"));
	fn.glFogCoordd ( a);
}

void OSMesaDriver::nfglFogCoorddv (const GLdouble * a)
{
	D(bug("nfosmesa: glFogCoorddv"));
	fn.glFogCoorddv ( a);
}

void OSMesaDriver::nfglFogCoordPointer (GLenum a, GLsizei b, const GLvoid * c)
{
	D(bug("nfosmesa: glFogCoordPointer"));
	fn.glFogCoordPointer ( a,  b,  c);
}

void OSMesaDriver::nfglMultiDrawArrays (GLenum a, GLint * b, GLsizei * c, GLsizei d)
{
	D(bug("nfosmesa: glMultiDrawArrays"));
	fn.glMultiDrawArrays ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiDrawElements (GLenum a, const GLsizei * b, GLenum c, const GLvoid* * d, GLsizei e)
{
	D(bug("nfosmesa: glMultiDrawElements"));
	fn.glMultiDrawElements ( a,  b,  c, d,  e);
}

void OSMesaDriver::nfglPointParameterf (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPointParameterf"));
	fn.glPointParameterf ( a,  b);
}

void OSMesaDriver::nfglPointParameterfv (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glPointParameterfv"));
	fn.glPointParameterfv ( a,  b);
}

void OSMesaDriver::nfglPointParameteri (GLenum a, GLint b)
{
	D(bug("nfosmesa: glPointParameteri"));
	fn.glPointParameteri ( a,  b);
}

void OSMesaDriver::nfglPointParameteriv (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glPointParameteriv"));
	fn.glPointParameteriv ( a,  b);
}

void OSMesaDriver::nfglSecondaryColor3b (GLbyte a, GLbyte b, GLbyte c)
{
	D(bug("nfosmesa: glSecondaryColor3b"));
	fn.glSecondaryColor3b ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3bv (const GLbyte * a)
{
	D(bug("nfosmesa: glSecondaryColor3bv"));
	fn.glSecondaryColor3bv ( a);
}

void OSMesaDriver::nfglSecondaryColor3d (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glSecondaryColor3d"));
	fn.glSecondaryColor3d ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3dv (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glSecondaryColor3dv"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3dv (tmp);
}

void OSMesaDriver::nfglSecondaryColor3f (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glSecondaryColor3f"));
	fn.glSecondaryColor3f ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3fv (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glSecondaryColor3fv"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3fv ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3i (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glSecondaryColor3i"));
	fn.glSecondaryColor3i ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3iv (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glSecondaryColor3iv"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3iv ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3s (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glSecondaryColor3s"));
	fn.glSecondaryColor3s ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3sv (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glSecondaryColor3sv"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glSecondaryColor3sv (tmp);
}

void OSMesaDriver::nfglSecondaryColor3ub (GLubyte a, GLubyte b, GLubyte c)
{
	D(bug("nfosmesa: glSecondaryColor3ub"));
	fn.glSecondaryColor3ub ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3ubv (const GLubyte * a)
{
	D(bug("nfosmesa: glSecondaryColor3ubv"));
	fn.glSecondaryColor3ubv ( a);
}

void OSMesaDriver::nfglSecondaryColor3ui (GLuint a, GLuint b, GLuint c)
{
	D(bug("nfosmesa: glSecondaryColor3ui"));
	fn.glSecondaryColor3ui ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3uiv (const GLuint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glSecondaryColor3uiv"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3uiv ( (GLuint *)tmp);
}

void OSMesaDriver::nfglSecondaryColor3us (GLushort a, GLushort b, GLushort c)
{
	D(bug("nfosmesa: glSecondaryColor3us"));
	fn.glSecondaryColor3us ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3usv (const GLushort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glSecondaryColor3usv"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glSecondaryColor3usv ( (GLushort *)tmp);
}

void OSMesaDriver::nfglSecondaryColorPointer (GLint a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glSecondaryColorPointer"));
	fn.glSecondaryColorPointer ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos2d (GLdouble a, GLdouble b)
{
	D(bug("nfosmesa: glWindowPos2d"));
	fn.glWindowPos2d ( a,  b);
}

void OSMesaDriver::nfglWindowPos2dv (const GLdouble * a)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glWindowPos2dv"));
	Atari2HostDoublePtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2dv (tmp);
}

void OSMesaDriver::nfglWindowPos2f (GLfloat a, GLfloat b)
{
	D(bug("nfosmesa: glWindowPos2f"));
	fn.glWindowPos2f ( a,  b);
}

void OSMesaDriver::nfglWindowPos2fv (const GLfloat * a)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glWindowPos2fv"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2fv ( tmp);
}

void OSMesaDriver::nfglWindowPos2i (GLint a, GLint b)
{
	D(bug("nfosmesa: glWindowPos2i"));
	fn.glWindowPos2i ( a,  b);
}

void OSMesaDriver::nfglWindowPos2iv (const GLint * a)
{
	GLint tmp[2];

	D(bug("nfosmesa: glWindowPos2iv"));
	Atari2HostIntPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2iv (tmp);
}

void OSMesaDriver::nfglWindowPos2s (GLshort a, GLshort b)
{
	D(bug("nfosmesa: glWindowPos2s"));
	fn.glWindowPos2s ( a,  b);
}

void OSMesaDriver::nfglWindowPos2sv (const GLshort * a)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glWindowPos2sv"));
	Atari2HostShortPtr(2, (Uint16 *)a, tmp);
	fn.glWindowPos2sv ( tmp);
}

void OSMesaDriver::nfglWindowPos3d (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glWindowPos3d"));
	fn.glWindowPos3d ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3dv (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glWindowPos3dv"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3dv (tmp);
}

void OSMesaDriver::nfglWindowPos3f (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glWindowPos3f"));
	fn.glWindowPos3f ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3fv (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glWindowPos3fv"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3fv ( tmp);
}

void OSMesaDriver::nfglWindowPos3i (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glWindowPos3i"));
	fn.glWindowPos3i ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3iv (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glWindowPos3iv"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3iv ( tmp);
}

void OSMesaDriver::nfglWindowPos3s (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glWindowPos3s"));
	fn.glWindowPos3s ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3sv (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glWindowPos3sv"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glWindowPos3sv ( tmp);
}

void OSMesaDriver::nfglGenQueries (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenQueries"));
	fn.glGenQueries ( a,  b);
}

void OSMesaDriver::nfglDeleteQueries (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteQueries"));
	fn.glDeleteQueries ( a,  b);
}

GLboolean OSMesaDriver::nfglIsQuery (GLuint a)
{
	D(bug("nfosmesa: glIsQuery"));
	return fn.glIsQuery ( a);
}

void OSMesaDriver::nfglBeginQuery (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBeginQuery"));
	fn.glBeginQuery ( a,  b);
}

void OSMesaDriver::nfglEndQuery (GLenum a)
{
	D(bug("nfosmesa: glEndQuery"));
	fn.glEndQuery ( a);
}

void OSMesaDriver::nfglGetQueryiv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetQueryiv"));
	fn.glGetQueryiv ( a,  b,  c);
}

void OSMesaDriver::nfglGetQueryObjectiv (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetQueryObjectiv"));
	fn.glGetQueryObjectiv ( a,  b,  c);
}

void OSMesaDriver::nfglGetQueryObjectuiv (GLuint a, GLenum b, GLuint * c)
{
	D(bug("nfosmesa: glGetQueryObjectuiv"));
	fn.glGetQueryObjectuiv ( a,  b,  c);
}

void OSMesaDriver::nfglBindBuffer (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBindBuffer"));
	fn.glBindBuffer ( a,  b);
}

void OSMesaDriver::nfglDeleteBuffers (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteBuffers"));
	fn.glDeleteBuffers ( a,  b);
}

void OSMesaDriver::nfglGenBuffers (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenBuffers"));
	fn.glGenBuffers ( a,  b);
}

GLboolean OSMesaDriver::nfglIsBuffer (GLuint a)
{
	D(bug("nfosmesa: glIsBuffer"));
	return fn.glIsBuffer ( a);
}

void OSMesaDriver::nfglBufferData (GLenum a, GLsizeiptr b, const GLvoid * c, GLenum d)
{
	D(bug("nfosmesa: glBufferData"));
	fn.glBufferData ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBufferSubData (GLenum a, GLintptr b, GLsizeiptr c, const GLvoid * d)
{
	D(bug("nfosmesa: glBufferSubData"));
	fn.glBufferSubData ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetBufferSubData (GLenum a, GLintptr b, GLsizeiptr c, GLvoid * d)
{
	D(bug("nfosmesa: glGetBufferSubData"));
	fn.glGetBufferSubData ( a,  b,  c,  d);
}

GLvoid* OSMesaDriver::nfglMapBuffer (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glMapBuffer"));
	return fn.glMapBuffer ( a,  b);
}

GLboolean OSMesaDriver::nfglUnmapBuffer (GLenum a)
{
	D(bug("nfosmesa: glUnmapBuffer"));
	return fn.glUnmapBuffer ( a);
}

void OSMesaDriver::nfglGetBufferParameteriv (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetBufferParameteriv"));
	fn.glGetBufferParameteriv ( a,  b,  c);
}

void OSMesaDriver::nfglGetBufferPointerv (GLenum a, GLenum b, GLvoid* * c)
{
	D(bug("nfosmesa: glGetBufferPointerv"));
	fn.glGetBufferPointerv ( a,  b, c);
}

void OSMesaDriver::nfglActiveTextureARB (GLenum a)
{
	D(bug("nfosmesa: glActiveTextureARB"));
	fn.glActiveTextureARB ( a);
}

void OSMesaDriver::nfglClientActiveTextureARB (GLenum a)
{
	D(bug("nfosmesa: glClientActiveTextureARB"));
	fn.glClientActiveTextureARB ( a);
}

void OSMesaDriver::nfglMultiTexCoord1dARB (GLenum a, GLdouble b)
{
	D(bug("nfosmesa: glMultiTexCoord1dARB"));
	fn.glMultiTexCoord1dARB ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1dvARB (GLenum a, const GLdouble * b)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1dvARB"));
	Atari2HostDoublePtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1dvARB ( a,  tmp);
}

void OSMesaDriver::nfglMultiTexCoord1fARB (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glMultiTexCoord1fARB"));
	fn.glMultiTexCoord1fARB ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1fvARB (GLenum a, const GLfloat * b)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1fvARB"));
	Atari2HostFloatPtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1fvARB ( a,  tmp);
}

void OSMesaDriver::nfglMultiTexCoord1iARB (GLenum a, GLint b)
{
	D(bug("nfosmesa: glMultiTexCoord1iARB"));
	fn.glMultiTexCoord1iARB ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1ivARB (GLenum a, const GLint * b)
{
	GLint tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1ivARB"));
	Atari2HostIntPtr(1, (Uint32 *)b, tmp);
	fn.glMultiTexCoord1ivARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord1sARB (GLenum a, GLshort b)
{
	D(bug("nfosmesa: glMultiTexCoord1sARB"));
	fn.glMultiTexCoord1sARB ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1svARB (GLenum a, const GLshort * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glMultiTexCoord1svARB"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glMultiTexCoord1svARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2dARB (GLenum a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glMultiTexCoord2dARB"));
	fn.glMultiTexCoord2dARB ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2dvARB (GLenum a, const GLdouble * b)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2dvARB"));
	Atari2HostDoublePtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2dvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2fARB (GLenum a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glMultiTexCoord2fARB"));
	fn.glMultiTexCoord2fARB ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2fvARB (GLenum a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2fvARB"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2fvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2iARB (GLenum a, GLint b, GLint c)
{
	D(bug("nfosmesa: glMultiTexCoord2iARB"));
	fn.glMultiTexCoord2iARB ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2ivARB (GLenum a, const GLint * b)
{
	GLint tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2ivARB"));
	Atari2HostIntPtr(2, (Uint32 *)b, tmp);
	fn.glMultiTexCoord2ivARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord2sARB (GLenum a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glMultiTexCoord2sARB"));
	fn.glMultiTexCoord2sARB ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2svARB (GLenum a, const GLshort * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glMultiTexCoord2svARB"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glMultiTexCoord2svARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3dARB (GLenum a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glMultiTexCoord3dARB"));
	fn.glMultiTexCoord3dARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3dvARB (GLenum a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3dvARB"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3dvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3fARB (GLenum a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glMultiTexCoord3fARB"));
	fn.glMultiTexCoord3fARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3fvARB (GLenum a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3fvARB"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3fvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3iARB (GLenum a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glMultiTexCoord3iARB"));
	fn.glMultiTexCoord3iARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3ivARB (GLenum a, const GLint * b)
{
	GLint tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3ivARB"));
	Atari2HostIntPtr(3, (Uint32 *)b, tmp);
	fn.glMultiTexCoord3ivARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord3sARB (GLenum a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glMultiTexCoord3sARB"));
	fn.glMultiTexCoord3sARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3svARB (GLenum a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glMultiTexCoord3svARB"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glMultiTexCoord3svARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4dARB (GLenum a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{
	D(bug("nfosmesa: glMultiTexCoord4dARB"));
	fn.glMultiTexCoord4dARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4dvARB (GLenum a, const GLdouble * b)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4dvARB"));
	Atari2HostDoublePtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4dvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4fARB (GLenum a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glMultiTexCoord4fARB"));
	fn.glMultiTexCoord4fARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4fvARB (GLenum a, const GLfloat * b)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4fvARB"));
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4fvARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4iARB (GLenum a, GLint b, GLint c, GLint d, GLint e)
{
	D(bug("nfosmesa: glMultiTexCoord4iARB"));
	fn.glMultiTexCoord4iARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4ivARB (GLenum a, const GLint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4ivARB"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glMultiTexCoord4ivARB ( a, tmp);
}

void OSMesaDriver::nfglMultiTexCoord4sARB (GLenum a, GLshort b, GLshort c, GLshort d, GLshort e)
{
	D(bug("nfosmesa: glMultiTexCoord4sARB"));
	fn.glMultiTexCoord4sARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4svARB (GLenum a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glMultiTexCoord4svARB"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glMultiTexCoord4svARB ( a, tmp);
}

void OSMesaDriver::nfglLoadTransposeMatrixfARB (const GLfloat * a)
{
	GLfloat tmp[16];

	D(bug("nfosmesa: glLoadTransposeMatrixfARB"));
	Atari2HostFloatPtr(16, (Uint32 *)a, tmp);
	fn.glLoadTransposeMatrixfARB ( tmp);
}

void OSMesaDriver::nfglLoadTransposeMatrixdARB (const GLdouble * a)
{
	GLdouble tmp[16];

	D(bug("nfosmesa: glLoadTransposeMatrixdARB"));
	Atari2HostDoublePtr(16, (Uint32 *)a, tmp);
	fn.glLoadTransposeMatrixdARB ( tmp);
}

void OSMesaDriver::nfglMultTransposeMatrixfARB (const GLfloat * a)
{
	GLfloat tmp[16];

	D(bug("nfosmesa: glMultTransposeMatrixfARB"));
	Atari2HostFloatPtr(16, (Uint32 *)a, tmp);
	fn.glMultTransposeMatrixfARB ( tmp);
}

void OSMesaDriver::nfglMultTransposeMatrixdARB (const GLdouble * a)
{
	GLdouble tmp[16];

	D(bug("nfosmesa: glMultTransposeMatrixdARB"));
	Atari2HostDoublePtr(16, (Uint32 *)a, tmp);
	fn.glMultTransposeMatrixdARB ( tmp);
}

void OSMesaDriver::nfglSampleCoverageARB (GLclampf a, GLboolean b)
{
	D(bug("nfosmesa: glSampleCoverageARB"));
	fn.glSampleCoverageARB ( a,  b);
}

void OSMesaDriver::nfglCompressedTexImage3DARB (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLsizei h, const GLvoid * i)
{
	D(bug("nfosmesa: glCompressedTexImage3DARB"));
	fn.glCompressedTexImage3DARB ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglCompressedTexImage2DARB (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLint f, GLsizei g, const GLvoid * h)
{
	D(bug("nfosmesa: glCompressedTexImage2DARB"));
	fn.glCompressedTexImage2DARB ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglCompressedTexImage1DARB (GLenum a, GLint b, GLenum c, GLsizei d, GLint e, GLsizei f, const GLvoid * g)
{
	D(bug("nfosmesa: glCompressedTexImage1DARB"));
	fn.glCompressedTexImage1DARB ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglCompressedTexSubImage3DARB (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLsizei j, const GLvoid * k)
{
	D(bug("nfosmesa: glCompressedTexSubImage3DARB"));
	fn.glCompressedTexSubImage3DARB ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglCompressedTexSubImage2DARB (GLenum a, GLint b, GLint c, GLint d, GLsizei e, GLsizei f, GLenum g, GLsizei h, const GLvoid * i)
{
	D(bug("nfosmesa: glCompressedTexSubImage2DARB"));
	fn.glCompressedTexSubImage2DARB ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglCompressedTexSubImage1DARB (GLenum a, GLint b, GLint c, GLsizei d, GLenum e, GLsizei f, const GLvoid * g)
{
	D(bug("nfosmesa: glCompressedTexSubImage1DARB"));
	fn.glCompressedTexSubImage1DARB ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglGetCompressedTexImageARB (GLenum a, GLint b, GLvoid * c)
{
	D(bug("nfosmesa: glGetCompressedTexImageARB"));
	fn.glGetCompressedTexImageARB ( a,  b,  c);
}

void OSMesaDriver::nfglPointParameterfARB (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPointParameterfARB"));
	fn.glPointParameterfARB ( a,  b);
}

void OSMesaDriver::nfglPointParameterfvARB (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glPointParameterfvARB"));
	fn.glPointParameterfvARB ( a,  b);
}

void OSMesaDriver::nfglWeightbvARB (GLint a, const GLbyte * b)
{
	D(bug("nfosmesa: glWeightbvARB"));
	fn.glWeightbvARB ( a,  b);
}

void OSMesaDriver::nfglWeightsvARB (GLint a, const GLshort * b)
{
	D(bug("nfosmesa: glWeightsvARB"));
	fn.glWeightsvARB ( a,  b);
}

void OSMesaDriver::nfglWeightivARB (GLint a, const GLint * b)
{
	D(bug("nfosmesa: glWeightivARB"));
	fn.glWeightivARB ( a,  b);
}

void OSMesaDriver::nfglWeightfvARB (GLint a, const GLfloat * b)
{
	D(bug("nfosmesa: glWeightfvARB"));
	fn.glWeightfvARB ( a,  b);
}

void OSMesaDriver::nfglWeightdvARB (GLint a, const GLdouble * b)
{
	D(bug("nfosmesa: glWeightdvARB"));
	fn.glWeightdvARB ( a,  b);
}

void OSMesaDriver::nfglWeightubvARB (GLint a, const GLubyte * b)
{
	D(bug("nfosmesa: glWeightubvARB"));
	fn.glWeightubvARB ( a,  b);
}

void OSMesaDriver::nfglWeightusvARB (GLint a, const GLushort * b)
{
	D(bug("nfosmesa: glWeightusvARB"));
	fn.glWeightusvARB ( a,  b);
}

void OSMesaDriver::nfglWeightuivARB (GLint a, const GLuint * b)
{
	D(bug("nfosmesa: glWeightuivARB"));
	fn.glWeightuivARB ( a,  b);
}

void OSMesaDriver::nfglWeightPointerARB (GLint a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glWeightPointerARB"));
	fn.glWeightPointerARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexBlendARB (GLint a)
{
	D(bug("nfosmesa: glVertexBlendARB"));
	fn.glVertexBlendARB ( a);
}

void OSMesaDriver::nfglCurrentPaletteMatrixARB (GLint a)
{
	D(bug("nfosmesa: glCurrentPaletteMatrixARB"));
	fn.glCurrentPaletteMatrixARB ( a);
}

void OSMesaDriver::nfglMatrixIndexubvARB (GLint a, const GLubyte * b)
{
	D(bug("nfosmesa: glMatrixIndexubvARB"));
	fn.glMatrixIndexubvARB ( a,  b);
}

void OSMesaDriver::nfglMatrixIndexusvARB (GLint a, const GLushort * b)
{
	D(bug("nfosmesa: glMatrixIndexusvARB"));
	fn.glMatrixIndexusvARB ( a,  b);
}

void OSMesaDriver::nfglMatrixIndexuivARB (GLint a, const GLuint * b)
{
	D(bug("nfosmesa: glMatrixIndexuivARB"));
	fn.glMatrixIndexuivARB ( a,  b);
}

void OSMesaDriver::nfglMatrixIndexPointerARB (GLint a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glMatrixIndexPointerARB"));
	fn.glMatrixIndexPointerARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos2dARB (GLdouble a, GLdouble b)
{
	D(bug("nfosmesa: glWindowPos2dARB"));
	fn.glWindowPos2dARB ( a,  b);
}

void OSMesaDriver::nfglWindowPos2dvARB (const GLdouble * a)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glWindowPos2dvARB"));
	Atari2HostDoublePtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2dvARB ( tmp);
}

void OSMesaDriver::nfglWindowPos2fARB (GLfloat a, GLfloat b)
{
	D(bug("nfosmesa: glWindowPos2fARB"));
	fn.glWindowPos2fARB ( a,  b);
}

void OSMesaDriver::nfglWindowPos2fvARB (const GLfloat * a)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glWindowPos2fvARB"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2fvARB ( tmp);
}

void OSMesaDriver::nfglWindowPos2iARB (GLint a, GLint b)
{
	D(bug("nfosmesa: glWindowPos2iARB"));
	fn.glWindowPos2iARB ( a,  b);
}

void OSMesaDriver::nfglWindowPos2ivARB (const GLint * a)
{
	GLint tmp[2];

	D(bug("nfosmesa: glWindowPos2ivARB"));
	Atari2HostIntPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2ivARB ( tmp);
}

void OSMesaDriver::nfglWindowPos2sARB (GLshort a, GLshort b)
{
	D(bug("nfosmesa: glWindowPos2sARB"));
	fn.glWindowPos2sARB ( a,  b);
}

void OSMesaDriver::nfglWindowPos2svARB (const GLshort * a)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glWindowPos2svARB"));
	Atari2HostShortPtr(2, (Uint16 *)a, tmp);
	fn.glWindowPos2svARB ( tmp);
}

void OSMesaDriver::nfglWindowPos3dARB (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glWindowPos3dARB"));
	fn.glWindowPos3dARB ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3dvARB (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glWindowPos3dvARB"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3dvARB ( tmp);
}

void OSMesaDriver::nfglWindowPos3fARB (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glWindowPos3fARB"));
	fn.glWindowPos3fARB ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3fvARB (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glWindowPos3fvARB"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3fvARB ( tmp);
}

void OSMesaDriver::nfglWindowPos3iARB (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glWindowPos3iARB"));
	fn.glWindowPos3iARB ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3ivARB (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glWindowPos3ivARB"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3ivARB ( tmp);
}

void OSMesaDriver::nfglWindowPos3sARB (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glWindowPos3sARB"));
	fn.glWindowPos3sARB ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3svARB (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glWindowPos3svARB"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glWindowPos3svARB ( tmp);
}

void OSMesaDriver::nfglVertexAttrib1dARB (GLuint a, GLdouble b)
{
	D(bug("nfosmesa: glVertexAttrib1dARB"));
	fn.glVertexAttrib1dARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1dvARB (GLuint a, const GLdouble * b)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glVertexAttrib1dvARB"));
	Atari2HostDoublePtr(1, (Uint32 *)b, tmp);
	fn.glVertexAttrib1dvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib1fARB (GLuint a, GLfloat b)
{
	D(bug("nfosmesa: glVertexAttrib1fARB"));
	fn.glVertexAttrib1fARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1fvARB (GLuint a, const GLfloat * b)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glVertexAttrib1fvARB"));
	Atari2HostFloatPtr(1, (Uint32 *)b, tmp);
	fn.glVertexAttrib1fvARB ( a,  tmp);
}

void OSMesaDriver::nfglVertexAttrib1sARB (GLuint a, GLshort b)
{
	D(bug("nfosmesa: glVertexAttrib1sARB"));
	fn.glVertexAttrib1sARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1svARB (GLuint a, const GLshort * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexAttrib1svARB"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glVertexAttrib1svARB ( a,  tmp);
}

void OSMesaDriver::nfglVertexAttrib2dARB (GLuint a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glVertexAttrib2dARB"));
	fn.glVertexAttrib2dARB ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2dvARB (GLuint a, const GLdouble * b)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glVertexAttrib2dvARB"));
	Atari2HostDoublePtr(2, (Uint32 *)b, tmp);
	fn.glVertexAttrib2dvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib2fARB (GLuint a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glVertexAttrib2fARB"));
	fn.glVertexAttrib2fARB ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2fvARB (GLuint a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glVertexAttrib2fvARB"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glVertexAttrib2fvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib2sARB (GLuint a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glVertexAttrib2sARB"));
	fn.glVertexAttrib2sARB ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2svARB (GLuint a, const GLshort * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexAttrib2svARB"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glVertexAttrib2svARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3dARB (GLuint a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glVertexAttrib3dARB"));
	fn.glVertexAttrib3dARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3dvARB (GLuint a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glVertexAttrib3dvARB"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glVertexAttrib3dvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3fARB (GLuint a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glVertexAttrib3fARB"));
	fn.glVertexAttrib3fARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3fvARB (GLuint a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glVertexAttrib3fvARB"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glVertexAttrib3fvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3sARB (GLuint a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glVertexAttrib3sARB"));
	fn.glVertexAttrib3sARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3svARB (GLuint a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexAttrib3svARB"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glVertexAttrib3svARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4NbvARB (GLuint a, const GLbyte * b)
{
	D(bug("nfosmesa: glVertexAttrib4NbvARB"));
	fn.glVertexAttrib4NbvARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib4NivARB (GLuint a, const GLint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glVertexAttrib4NivARB"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4NivARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4NsvARB (GLuint a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4NsvARB"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4NsvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4NubARB (GLuint a, GLubyte b, GLubyte c, GLubyte d, GLubyte e)
{
	D(bug("nfosmesa: glVertexAttrib4NubARB"));
	fn.glVertexAttrib4NubARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4NubvARB (GLuint a, const GLubyte * b)
{
	D(bug("nfosmesa: glVertexAttrib4NubvARB"));
	fn.glVertexAttrib4NubvARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib4NuivARB (GLuint a, const GLuint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glVertexAttrib4NuivARB"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4NuivARB ( a, (GLuint *)tmp);
}

void OSMesaDriver::nfglVertexAttrib4NusvARB (GLuint a, const GLushort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4NusvARB"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4NusvARB ( a, (GLushort *)tmp);
}

void OSMesaDriver::nfglVertexAttrib4bvARB (GLuint a, const GLbyte * b)
{
	D(bug("nfosmesa: glVertexAttrib4bvARB"));
	fn.glVertexAttrib4bvARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib4dARB (GLuint a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{
	D(bug("nfosmesa: glVertexAttrib4dARB"));
	fn.glVertexAttrib4dARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4dvARB (GLuint a, const GLdouble * b)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glVertexAttrib4dvARB"));
	Atari2HostDoublePtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4dvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4fARB (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glVertexAttrib4fARB"));
	fn.glVertexAttrib4fARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4fvARB (GLuint a, const GLfloat * b)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glVertexAttrib4fvARB"));
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4fvARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4ivARB (GLuint a, const GLint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glVertexAttrib4ivARB"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4ivARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4sARB (GLuint a, GLshort b, GLshort c, GLshort d, GLshort e)
{
	D(bug("nfosmesa: glVertexAttrib4sARB"));
	fn.glVertexAttrib4sARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4svARB (GLuint a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4svARB"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4svARB ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4ubvARB (GLuint a, const GLubyte * b)
{
	D(bug("nfosmesa: glVertexAttrib4ubvARB"));
	fn.glVertexAttrib4ubvARB ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib4uivARB (GLuint a, const GLuint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glVertexAttrib4uivARB"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4uivARB ( a, (GLuint *)tmp);
}

void OSMesaDriver::nfglVertexAttrib4usvARB (GLuint a, const GLushort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4usvARB"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4usvARB ( a, (GLushort *)tmp);
}

void OSMesaDriver::nfglVertexAttribPointerARB (GLuint a, GLint b, GLenum c, GLboolean d, GLsizei e, const GLvoid * f)
{
	D(bug("nfosmesa: glVertexAttribPointerARB"));
	fn.glVertexAttribPointerARB ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglEnableVertexAttribArrayARB (GLuint a)
{
	D(bug("nfosmesa: glEnableVertexAttribArrayARB"));
	fn.glEnableVertexAttribArrayARB ( a);
}

void OSMesaDriver::nfglDisableVertexAttribArrayARB (GLuint a)
{
	D(bug("nfosmesa: glDisableVertexAttribArrayARB"));
	fn.glDisableVertexAttribArrayARB ( a);
}

void OSMesaDriver::nfglProgramStringARB (GLenum a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glProgramStringARB"));
	fn.glProgramStringARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBindProgramARB (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBindProgramARB"));
	fn.glBindProgramARB ( a,  b);
}

void OSMesaDriver::nfglDeleteProgramsARB (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteProgramsARB"));
	fn.glDeleteProgramsARB ( a,  b);
}

void OSMesaDriver::nfglGenProgramsARB (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenProgramsARB"));
	fn.glGenProgramsARB ( a,  b);
}

void OSMesaDriver::nfglProgramEnvParameter4dARB (GLenum a, GLuint b, GLdouble c, GLdouble d, GLdouble e, GLdouble f)
{
	D(bug("nfosmesa: glProgramEnvParameter4dARB"));
	fn.glProgramEnvParameter4dARB ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramEnvParameter4dvARB (GLenum a, GLuint b, const GLdouble * c)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glProgramEnvParameter4dvARB"));
	Atari2HostDoublePtr(4, (Uint32 *)c, tmp);
	fn.glProgramEnvParameter4dvARB ( a,  b,  tmp);
}

void OSMesaDriver::nfglProgramEnvParameter4fARB (GLenum a, GLuint b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glProgramEnvParameter4fARB"));
	fn.glProgramEnvParameter4fARB ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramEnvParameter4fvARB (GLenum a, GLuint b, const GLfloat * c)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glProgramEnvParameter4fvARB"));
	Atari2HostFloatPtr(4, (Uint32 *)c, tmp);
	fn.glProgramEnvParameter4fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglProgramLocalParameter4dARB (GLenum a, GLuint b, GLdouble c, GLdouble d, GLdouble e, GLdouble f)
{
	D(bug("nfosmesa: glProgramLocalParameter4dARB"));
	fn.glProgramLocalParameter4dARB ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramLocalParameter4dvARB (GLenum a, GLuint b, const GLdouble * c)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glProgramLocalParameter4dvARB"));
	Atari2HostDoublePtr(4, (Uint32 *)c, tmp);
	fn.glProgramLocalParameter4dvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglProgramLocalParameter4fARB (GLenum a, GLuint b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glProgramLocalParameter4fARB"));
	fn.glProgramLocalParameter4fARB ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramLocalParameter4fvARB (GLenum a, GLuint b, const GLfloat * c)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glProgramLocalParameter4fvARB"));
	Atari2HostFloatPtr(4, (Uint32 *)c, tmp);
	fn.glProgramLocalParameter4fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglGetProgramEnvParameterdvARB (GLenum a, GLuint b, GLdouble * c)
{
	D(bug("nfosmesa: glGetProgramEnvParameterdvARB"));
	fn.glGetProgramEnvParameterdvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramEnvParameterfvARB (GLenum a, GLuint b, GLfloat * c)
{
	D(bug("nfosmesa: glGetProgramEnvParameterfvARB"));
	fn.glGetProgramEnvParameterfvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramLocalParameterdvARB (GLenum a, GLuint b, GLdouble * c)
{
	D(bug("nfosmesa: glGetProgramLocalParameterdvARB"));
	fn.glGetProgramLocalParameterdvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramLocalParameterfvARB (GLenum a, GLuint b, GLfloat * c)
{
	D(bug("nfosmesa: glGetProgramLocalParameterfvARB"));
	fn.glGetProgramLocalParameterfvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramivARB (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetProgramivARB"));
	fn.glGetProgramivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramStringARB (GLenum a, GLenum b, GLvoid * c)
{
	D(bug("nfosmesa: glGetProgramStringARB"));
	fn.glGetProgramStringARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribdvARB (GLuint a, GLenum b, GLdouble * c)
{
	D(bug("nfosmesa: glGetVertexAttribdvARB"));
	fn.glGetVertexAttribdvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribfvARB (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetVertexAttribfvARB"));
	fn.glGetVertexAttribfvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribivARB (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetVertexAttribivARB"));
	fn.glGetVertexAttribivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribPointervARB (GLuint a, GLenum b, GLvoid* * c)
{
	D(bug("nfosmesa: glGetVertexAttribPointervARB"));
	fn.glGetVertexAttribPointervARB ( a,  b, c);
}

GLboolean OSMesaDriver::nfglIsProgramARB (GLuint a)
{
	D(bug("nfosmesa: glIsProgramARB"));
	return fn.glIsProgramARB ( a);
}

void OSMesaDriver::nfglBindBufferARB (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBindBufferARB"));
	fn.glBindBufferARB ( a,  b);
}

void OSMesaDriver::nfglDeleteBuffersARB (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteBuffersARB"));
	fn.glDeleteBuffersARB ( a,  b);
}

void OSMesaDriver::nfglGenBuffersARB (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenBuffersARB"));
	fn.glGenBuffersARB ( a,  b);
}

GLboolean OSMesaDriver::nfglIsBufferARB (GLuint a)
{
	D(bug("nfosmesa: glIsBufferARB"));
	return fn.glIsBufferARB ( a);
}

void OSMesaDriver::nfglBufferDataARB (GLenum a, GLsizeiptrARB b, const GLvoid * c, GLenum d)
{
	D(bug("nfosmesa: glBufferDataARB"));
	fn.glBufferDataARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBufferSubDataARB (GLenum a, GLintptrARB b, GLsizeiptrARB c, const GLvoid * d)
{
	D(bug("nfosmesa: glBufferSubDataARB"));
	fn.glBufferSubDataARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetBufferSubDataARB (GLenum a, GLintptrARB b, GLsizeiptrARB c, GLvoid * d)
{
	D(bug("nfosmesa: glGetBufferSubDataARB"));
	fn.glGetBufferSubDataARB ( a,  b,  c,  d);
}

GLvoid* OSMesaDriver::nfglMapBufferARB (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glMapBufferARB"));
	return fn.glMapBufferARB ( a,  b);
}

GLboolean OSMesaDriver::nfglUnmapBufferARB (GLenum a)
{
	D(bug("nfosmesa: glUnmapBufferARB"));
	return fn.glUnmapBufferARB ( a);
}

void OSMesaDriver::nfglGetBufferParameterivARB (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetBufferParameterivARB"));
	fn.glGetBufferParameterivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetBufferPointervARB (GLenum a, GLenum b, GLvoid* * c)
{
	D(bug("nfosmesa: glGetBufferPointervARB"));
	fn.glGetBufferPointervARB ( a,  b, c);
}

void OSMesaDriver::nfglGenQueriesARB (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenQueriesARB"));
	fn.glGenQueriesARB ( a,  b);
}

void OSMesaDriver::nfglDeleteQueriesARB (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteQueriesARB"));
	fn.glDeleteQueriesARB ( a,  b);
}

GLboolean OSMesaDriver::nfglIsQueryARB (GLuint a)
{
	D(bug("nfosmesa: glIsQueryARB"));
	return fn.glIsQueryARB ( a);
}

void OSMesaDriver::nfglBeginQueryARB (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBeginQueryARB"));
	fn.glBeginQueryARB ( a,  b);
}

void OSMesaDriver::nfglEndQueryARB (GLenum a)
{
	D(bug("nfosmesa: glEndQueryARB"));
	fn.glEndQueryARB ( a);
}

void OSMesaDriver::nfglGetQueryivARB (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetQueryivARB"));
	fn.glGetQueryivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetQueryObjectivARB (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetQueryObjectivARB"));
	fn.glGetQueryObjectivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetQueryObjectuivARB (GLuint a, GLenum b, GLuint * c)
{
	D(bug("nfosmesa: glGetQueryObjectuivARB"));
	fn.glGetQueryObjectuivARB ( a,  b,  c);
}

void OSMesaDriver::nfglDeleteObjectARB (GLhandleARB a)
{
	D(bug("nfosmesa: glDeleteObjectARB"));
	fn.glDeleteObjectARB ( a);
}

GLhandleARB OSMesaDriver::nfglGetHandleARB (GLenum a)
{
	D(bug("nfosmesa: glGetHandleARB"));
	return fn.glGetHandleARB ( a);
}

void OSMesaDriver::nfglDetachObjectARB (GLhandleARB a, GLhandleARB b)
{
	D(bug("nfosmesa: glDetachObjectARB"));
	fn.glDetachObjectARB ( a,  b);
}

GLhandleARB OSMesaDriver::nfglCreateShaderObjectARB (GLenum a)
{
	D(bug("nfosmesa: glCreateShaderObjectARB"));
	return fn.glCreateShaderObjectARB ( a);
}

void OSMesaDriver::nfglShaderSourceARB (GLhandleARB a, GLsizei b, const GLcharARB* * c, const GLint * d)
{
	D(bug("nfosmesa: glShaderSourceARB"));
	fn.glShaderSourceARB ( a,  b, c,  d);
}

void OSMesaDriver::nfglCompileShaderARB (GLhandleARB a)
{
	D(bug("nfosmesa: glCompileShaderARB"));
	fn.glCompileShaderARB ( a);
}

GLhandleARB OSMesaDriver::nfglCreateProgramObjectARB (void)
{
	D(bug("nfosmesa: glCreateProgramObjectARB"));
	return fn.glCreateProgramObjectARB ();
}

void OSMesaDriver::nfglAttachObjectARB (GLhandleARB a, GLhandleARB b)
{
	D(bug("nfosmesa: glAttachObjectARB"));
	fn.glAttachObjectARB ( a,  b);
}

void OSMesaDriver::nfglLinkProgramARB (GLhandleARB a)
{
	D(bug("nfosmesa: glLinkProgramARB"));
	fn.glLinkProgramARB ( a);
}

void OSMesaDriver::nfglUseProgramObjectARB (GLhandleARB a)
{
	D(bug("nfosmesa: glUseProgramObjectARB"));
	fn.glUseProgramObjectARB ( a);
}

void OSMesaDriver::nfglValidateProgramARB (GLhandleARB a)
{
	D(bug("nfosmesa: glValidateProgramARB"));
	fn.glValidateProgramARB ( a);
}

void OSMesaDriver::nfglUniform1fARB (GLint a, GLfloat b)
{
	D(bug("nfosmesa: glUniform1fARB"));
	fn.glUniform1fARB ( a,  b);
}

void OSMesaDriver::nfglUniform2fARB (GLint a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glUniform2fARB"));
	fn.glUniform2fARB ( a,  b,  c);
}

void OSMesaDriver::nfglUniform3fARB (GLint a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glUniform3fARB"));
	fn.glUniform3fARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglUniform4fARB (GLint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glUniform4fARB"));
	fn.glUniform4fARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglUniform1iARB (GLint a, GLint b)
{
	D(bug("nfosmesa: glUniform1iARB"));
	fn.glUniform1iARB ( a,  b);
}

void OSMesaDriver::nfglUniform2iARB (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glUniform2iARB"));
	fn.glUniform2iARB ( a,  b,  c);
}

void OSMesaDriver::nfglUniform3iARB (GLint a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glUniform3iARB"));
	fn.glUniform3iARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglUniform4iARB (GLint a, GLint b, GLint c, GLint d, GLint e)
{
	D(bug("nfosmesa: glUniform4iARB"));
	fn.glUniform4iARB ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglUniform1fvARB (GLint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glUniform1fvARB"));
	Atari2HostFloatPtr(1, (Uint32 *)c, tmp);
	fn.glUniform1fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform2fvARB (GLint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glUniform2fvARB"));
	Atari2HostFloatPtr(2, (Uint32 *)c, tmp);
	fn.glUniform2fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform3fvARB (GLint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glUniform3fvARB"));
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp);
	fn.glUniform3fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform4fvARB (GLint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glUniform4fvARB"));
	Atari2HostFloatPtr(4, (Uint32 *)c, tmp);
	fn.glUniform4fvARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform1ivARB (GLint a, GLsizei b, const GLint * c)
{
	GLint tmp[1];

	D(bug("nfosmesa: glUniform1ivARB"));
	Atari2HostIntPtr(1, (Uint32 *)c, tmp);
	fn.glUniform1ivARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform2ivARB (GLint a, GLsizei b, const GLint * c)
{
	GLint tmp[2];

	D(bug("nfosmesa: glUniform2ivARB"));
	Atari2HostIntPtr(2, (Uint32 *)c, tmp);
	fn.glUniform2ivARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform3ivARB (GLint a, GLsizei b, const GLint * c)
{
	GLint tmp[3];

	D(bug("nfosmesa: glUniform3ivARB"));
	Atari2HostIntPtr(3, (Uint32 *)c, tmp);
	fn.glUniform3ivARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniform4ivARB (GLint a, GLsizei b, const GLint * c)
{
	GLint tmp[4];

	D(bug("nfosmesa: glUniform4ivARB"));
	Atari2HostIntPtr(4, (Uint32 *)c, tmp);
	fn.glUniform4ivARB ( a,  b, tmp);
}

void OSMesaDriver::nfglUniformMatrix2fvARB (GLint a, GLsizei b, GLboolean c, const GLfloat * d)
{
	D(bug("nfosmesa: glUniformMatrix2fvARB"));
	fn.glUniformMatrix2fvARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglUniformMatrix3fvARB (GLint a, GLsizei b, GLboolean c, const GLfloat * d)
{
	D(bug("nfosmesa: glUniformMatrix3fvARB"));
	fn.glUniformMatrix3fvARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglUniformMatrix4fvARB (GLint a, GLsizei b, GLboolean c, const GLfloat * d)
{
	D(bug("nfosmesa: glUniformMatrix4fvARB"));
	fn.glUniformMatrix4fvARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetObjectParameterfvARB (GLhandleARB a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetObjectParameterfvARB"));
	fn.glGetObjectParameterfvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetObjectParameterivARB (GLhandleARB a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetObjectParameterivARB"));
	fn.glGetObjectParameterivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetInfoLogARB (GLhandleARB a, GLsizei b, GLsizei * c, GLcharARB * d)
{
	D(bug("nfosmesa: glGetInfoLogARB"));
	fn.glGetInfoLogARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetAttachedObjectsARB (GLhandleARB a, GLsizei b, GLsizei * c, GLhandleARB * d)
{
	D(bug("nfosmesa: glGetAttachedObjectsARB"));
	fn.glGetAttachedObjectsARB ( a,  b,  c,  d);
}

GLint OSMesaDriver::nfglGetUniformLocationARB (GLhandleARB a, const GLcharARB * b)
{
	D(bug("nfosmesa: glGetUniformLocationARB"));
	return fn.glGetUniformLocationARB ( a,  b);
}

void OSMesaDriver::nfglGetActiveUniformARB (GLhandleARB a, GLuint b, GLsizei c, GLsizei * d, GLint * e, GLenum * f, GLcharARB * g)
{
	D(bug("nfosmesa: glGetActiveUniformARB"));
	fn.glGetActiveUniformARB ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglGetUniformfvARB (GLhandleARB a, GLint b, GLfloat * c)
{
	D(bug("nfosmesa: glGetUniformfvARB"));
	fn.glGetUniformfvARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetUniformivARB (GLhandleARB a, GLint b, GLint * c)
{
	D(bug("nfosmesa: glGetUniformivARB"));
	fn.glGetUniformivARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetShaderSourceARB (GLhandleARB a, GLsizei b, GLsizei * c, GLcharARB * d)
{
	D(bug("nfosmesa: glGetShaderSourceARB"));
	fn.glGetShaderSourceARB ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBindAttribLocationARB (GLhandleARB a, GLuint b, const GLcharARB * c)
{
	D(bug("nfosmesa: glBindAttribLocationARB"));
	fn.glBindAttribLocationARB ( a,  b,  c);
}

void OSMesaDriver::nfglGetActiveAttribARB (GLhandleARB a, GLuint b, GLsizei c, GLsizei * d, GLint * e, GLenum * f, GLcharARB * g)
{
	D(bug("nfosmesa: glGetActiveAttribARB"));
	fn.glGetActiveAttribARB ( a,  b,  c,  d,  e,  f,  g);
}

GLint OSMesaDriver::nfglGetAttribLocationARB (GLhandleARB a, const GLcharARB * b)
{
	D(bug("nfosmesa: glGetAttribLocationARB"));
	return fn.glGetAttribLocationARB ( a,  b);
}

void OSMesaDriver::nfglDrawBuffersARB (GLsizei a, const GLenum * b)
{
	D(bug("nfosmesa: glDrawBuffersARB"));
	fn.glDrawBuffersARB ( a,  b);
}

void OSMesaDriver::nfglBlendColorEXT (GLclampf a, GLclampf b, GLclampf c, GLclampf d)
{
	D(bug("nfosmesa: glBlendColorEXT"));
	fn.glBlendColorEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglPolygonOffsetEXT (GLfloat a, GLfloat b)
{
	D(bug("nfosmesa: glPolygonOffsetEXT"));
	fn.glPolygonOffsetEXT ( a,  b);
}

void OSMesaDriver::nfglTexImage3DEXT (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLenum h, GLenum i, const GLvoid * j)
{
	D(bug("nfosmesa: glTexImage3DEXT"));
	fn.glTexImage3DEXT ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j);
}

void OSMesaDriver::nfglTexSubImage3DEXT (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLenum j, const GLvoid * k)
{
	D(bug("nfosmesa: glTexSubImage3DEXT"));
	fn.glTexSubImage3DEXT ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglGetTexFilterFuncSGIS (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetTexFilterFuncSGIS"));
	fn.glGetTexFilterFuncSGIS ( a,  b,  c);
}

void OSMesaDriver::nfglTexFilterFuncSGIS (GLenum a, GLenum b, GLsizei c, const GLfloat * d)
{
	D(bug("nfosmesa: glTexFilterFuncSGIS"));
	fn.glTexFilterFuncSGIS ( a,  b,  c,  d);
}

void OSMesaDriver::nfglTexSubImage1DEXT (GLenum a, GLint b, GLint c, GLsizei d, GLenum e, GLenum f, const GLvoid * g)
{
	D(bug("nfosmesa: glTexSubImage1DEXT"));
	fn.glTexSubImage1DEXT ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglTexSubImage2DEXT (GLenum a, GLint b, GLint c, GLint d, GLsizei e, GLsizei f, GLenum g, GLenum h, const GLvoid * i)
{
	D(bug("nfosmesa: glTexSubImage2DEXT"));
	fn.glTexSubImage2DEXT ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglCopyTexImage1DEXT (GLenum a, GLint b, GLenum c, GLint d, GLint e, GLsizei f, GLint g)
{
	D(bug("nfosmesa: glCopyTexImage1DEXT"));
	fn.glCopyTexImage1DEXT ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglCopyTexImage2DEXT (GLenum a, GLint b, GLenum c, GLint d, GLint e, GLsizei f, GLsizei g, GLint h)
{
	D(bug("nfosmesa: glCopyTexImage2DEXT"));
	fn.glCopyTexImage2DEXT ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglCopyTexSubImage1DEXT (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f)
{
	D(bug("nfosmesa: glCopyTexSubImage1DEXT"));
	fn.glCopyTexSubImage1DEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglCopyTexSubImage2DEXT (GLenum a, GLint b, GLint c, GLint d, GLint e, GLint f, GLsizei g, GLsizei h)
{
	D(bug("nfosmesa: glCopyTexSubImage2DEXT"));
	fn.glCopyTexSubImage2DEXT ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglCopyTexSubImage3DEXT (GLenum a, GLint b, GLint c, GLint d, GLint e, GLint f, GLint g, GLsizei h, GLsizei i)
{
	D(bug("nfosmesa: glCopyTexSubImage3DEXT"));
	fn.glCopyTexSubImage3DEXT ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglGetHistogramEXT (GLenum a, GLboolean b, GLenum c, GLenum d, GLvoid * e)
{
	D(bug("nfosmesa: glGetHistogramEXT"));
	fn.glGetHistogramEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetHistogramParameterfvEXT (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetHistogramParameterfvEXT"));
	fn.glGetHistogramParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetHistogramParameterivEXT (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetHistogramParameterivEXT"));
	fn.glGetHistogramParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetMinmaxEXT (GLenum a, GLboolean b, GLenum c, GLenum d, GLvoid * e)
{
	D(bug("nfosmesa: glGetMinmaxEXT"));
	fn.glGetMinmaxEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetMinmaxParameterfvEXT (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetMinmaxParameterfvEXT"));
	fn.glGetMinmaxParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetMinmaxParameterivEXT (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetMinmaxParameterivEXT"));
	fn.glGetMinmaxParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglHistogramEXT (GLenum a, GLsizei b, GLenum c, GLboolean d)
{
	D(bug("nfosmesa: glHistogramEXT"));
	fn.glHistogramEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMinmaxEXT (GLenum a, GLenum b, GLboolean c)
{
	D(bug("nfosmesa: glMinmaxEXT"));
	fn.glMinmaxEXT ( a,  b,  c);
}

void OSMesaDriver::nfglResetHistogramEXT (GLenum a)
{
	D(bug("nfosmesa: glResetHistogramEXT"));
	fn.glResetHistogramEXT ( a);
}

void OSMesaDriver::nfglResetMinmaxEXT (GLenum a)
{
	D(bug("nfosmesa: glResetMinmaxEXT"));
	fn.glResetMinmaxEXT ( a);
}

void OSMesaDriver::nfglConvolutionFilter1DEXT (GLenum a, GLenum b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glConvolutionFilter1DEXT"));
	fn.glConvolutionFilter1DEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglConvolutionFilter2DEXT (GLenum a, GLenum b, GLsizei c, GLsizei d, GLenum e, GLenum f, const GLvoid * g)
{
	D(bug("nfosmesa: glConvolutionFilter2DEXT"));
	fn.glConvolutionFilter2DEXT ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglConvolutionParameterfEXT (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glConvolutionParameterfEXT"));
	fn.glConvolutionParameterfEXT ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameterfvEXT (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glConvolutionParameterfvEXT"));
	fn.glConvolutionParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameteriEXT (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glConvolutionParameteriEXT"));
	fn.glConvolutionParameteriEXT ( a,  b,  c);
}

void OSMesaDriver::nfglConvolutionParameterivEXT (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glConvolutionParameterivEXT"));
	fn.glConvolutionParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglCopyConvolutionFilter1DEXT (GLenum a, GLenum b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyConvolutionFilter1DEXT"));
	fn.glCopyConvolutionFilter1DEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglCopyConvolutionFilter2DEXT (GLenum a, GLenum b, GLint c, GLint d, GLsizei e, GLsizei f)
{
	D(bug("nfosmesa: glCopyConvolutionFilter2DEXT"));
	fn.glCopyConvolutionFilter2DEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglGetConvolutionFilterEXT (GLenum a, GLenum b, GLenum c, GLvoid * d)
{
	D(bug("nfosmesa: glGetConvolutionFilterEXT"));
	fn.glGetConvolutionFilterEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetConvolutionParameterfvEXT (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetConvolutionParameterfvEXT"));
	fn.glGetConvolutionParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetConvolutionParameterivEXT (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetConvolutionParameterivEXT"));
	fn.glGetConvolutionParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetSeparableFilterEXT (GLenum a, GLenum b, GLenum c, GLvoid * d, GLvoid * e, GLvoid * f)
{
	D(bug("nfosmesa: glGetSeparableFilterEXT"));
	fn.glGetSeparableFilterEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglSeparableFilter2DEXT (GLenum a, GLenum b, GLsizei c, GLsizei d, GLenum e, GLenum f, const GLvoid * g, const GLvoid * h)
{
	D(bug("nfosmesa: glSeparableFilter2DEXT"));
	fn.glSeparableFilter2DEXT ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglColorTableSGI (GLenum a, GLenum b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glColorTableSGI"));
	fn.glColorTableSGI ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglColorTableParameterfvSGI (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glColorTableParameterfvSGI"));
	fn.glColorTableParameterfvSGI ( a,  b,  c);
}

void OSMesaDriver::nfglColorTableParameterivSGI (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glColorTableParameterivSGI"));
	fn.glColorTableParameterivSGI ( a,  b,  c);
}

void OSMesaDriver::nfglCopyColorTableSGI (GLenum a, GLenum b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyColorTableSGI"));
	fn.glCopyColorTableSGI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetColorTableSGI (GLenum a, GLenum b, GLenum c, GLvoid * d)
{
	D(bug("nfosmesa: glGetColorTableSGI"));
	fn.glGetColorTableSGI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetColorTableParameterfvSGI (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetColorTableParameterfvSGI"));
	fn.glGetColorTableParameterfvSGI ( a,  b,  c);
}

void OSMesaDriver::nfglGetColorTableParameterivSGI (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetColorTableParameterivSGI"));
	fn.glGetColorTableParameterivSGI ( a,  b,  c);
}

void OSMesaDriver::nfglPixelTexGenSGIX (GLenum a)
{
	D(bug("nfosmesa: glPixelTexGenSGIX"));
	fn.glPixelTexGenSGIX ( a);
}

void OSMesaDriver::nfglPixelTexGenParameteriSGIS (GLenum a, GLint b)
{
	D(bug("nfosmesa: glPixelTexGenParameteriSGIS"));
	fn.glPixelTexGenParameteriSGIS ( a,  b);
}

void OSMesaDriver::nfglPixelTexGenParameterivSGIS (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glPixelTexGenParameterivSGIS"));
	fn.glPixelTexGenParameterivSGIS ( a,  b);
}

void OSMesaDriver::nfglPixelTexGenParameterfSGIS (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPixelTexGenParameterfSGIS"));
	fn.glPixelTexGenParameterfSGIS ( a,  b);
}

void OSMesaDriver::nfglPixelTexGenParameterfvSGIS (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glPixelTexGenParameterfvSGIS"));
	fn.glPixelTexGenParameterfvSGIS ( a,  b);
}

void OSMesaDriver::nfglGetPixelTexGenParameterivSGIS (GLenum a, GLint * b)
{
	D(bug("nfosmesa: glGetPixelTexGenParameterivSGIS"));
	fn.glGetPixelTexGenParameterivSGIS ( a,  b);
}

void OSMesaDriver::nfglGetPixelTexGenParameterfvSGIS (GLenum a, GLfloat * b)
{
	D(bug("nfosmesa: glGetPixelTexGenParameterfvSGIS"));
	fn.glGetPixelTexGenParameterfvSGIS ( a,  b);
}

void OSMesaDriver::nfglTexImage4DSGIS (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLsizei g, GLint h, GLenum i, GLenum j, const GLvoid * k)
{
	D(bug("nfosmesa: glTexImage4DSGIS"));
	fn.glTexImage4DSGIS ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglTexSubImage4DSGIS (GLenum a, GLint b, GLint c, GLint d, GLint e, GLint f, GLsizei g, GLsizei h, GLsizei i, GLsizei j, GLenum k, GLenum l, const GLvoid * m)
{
	D(bug("nfosmesa: glTexSubImage4DSGIS"));
	fn.glTexSubImage4DSGIS ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m);
}

GLboolean OSMesaDriver::nfglAreTexturesResidentEXT (GLsizei a, const GLuint * b, GLboolean * c)
{
	D(bug("nfosmesa: glAreTexturesResidentEXT"));
	return fn.glAreTexturesResidentEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBindTextureEXT (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBindTextureEXT"));
	fn.glBindTextureEXT ( a,  b);
}

void OSMesaDriver::nfglDeleteTexturesEXT (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteTexturesEXT"));
	fn.glDeleteTexturesEXT ( a,  b);
}

void OSMesaDriver::nfglGenTexturesEXT (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenTexturesEXT"));
	fn.glGenTexturesEXT ( a,  b);
}

GLboolean OSMesaDriver::nfglIsTextureEXT (GLuint a)
{
	D(bug("nfosmesa: glIsTextureEXT"));
	return fn.glIsTextureEXT ( a);
}

void OSMesaDriver::nfglPrioritizeTexturesEXT (GLsizei a, const GLuint * b, const GLclampf * c)
{
	D(bug("nfosmesa: glPrioritizeTexturesEXT"));
	fn.glPrioritizeTexturesEXT ( a,  b,  c);
}

void OSMesaDriver::nfglDetailTexFuncSGIS (GLenum a, GLsizei b, const GLfloat * c)
{
	D(bug("nfosmesa: glDetailTexFuncSGIS"));
	fn.glDetailTexFuncSGIS ( a,  b,  c);
}

void OSMesaDriver::nfglGetDetailTexFuncSGIS (GLenum a, GLfloat * b)
{
	D(bug("nfosmesa: glGetDetailTexFuncSGIS"));
	fn.glGetDetailTexFuncSGIS ( a,  b);
}

void OSMesaDriver::nfglSharpenTexFuncSGIS (GLenum a, GLsizei b, const GLfloat * c)
{
	D(bug("nfosmesa: glSharpenTexFuncSGIS"));
	fn.glSharpenTexFuncSGIS ( a,  b,  c);
}

void OSMesaDriver::nfglGetSharpenTexFuncSGIS (GLenum a, GLfloat * b)
{
	D(bug("nfosmesa: glGetSharpenTexFuncSGIS"));
	fn.glGetSharpenTexFuncSGIS ( a,  b);
}

void OSMesaDriver::nfglSampleMaskSGIS (GLclampf a, GLboolean b)
{
	D(bug("nfosmesa: glSampleMaskSGIS"));
	fn.glSampleMaskSGIS ( a,  b);
}

void OSMesaDriver::nfglSamplePatternSGIS (GLenum a)
{
	D(bug("nfosmesa: glSamplePatternSGIS"));
	fn.glSamplePatternSGIS ( a);
}

void OSMesaDriver::nfglArrayElementEXT (GLint a)
{
	D(bug("nfosmesa: glArrayElementEXT"));
	fn.glArrayElementEXT ( a);
}

void OSMesaDriver::nfglColorPointerEXT (GLint a, GLenum b, GLsizei c, GLsizei d, const GLvoid * e)
{
	D(bug("nfosmesa: glColorPointerEXT"));
	fn.glColorPointerEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglDrawArraysEXT (GLenum a, GLint b, GLsizei c)
{
	D(bug("nfosmesa: glDrawArraysEXT"));
	fn.glDrawArraysEXT ( a,  b,  c);
}

void OSMesaDriver::nfglEdgeFlagPointerEXT (GLsizei a, GLsizei b, const GLboolean * c)
{
	D(bug("nfosmesa: glEdgeFlagPointerEXT"));
	fn.glEdgeFlagPointerEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetPointervEXT (GLenum a, GLvoid* * b)
{
	D(bug("nfosmesa: glGetPointervEXT"));
	fn.glGetPointervEXT ( a, b);
}

void OSMesaDriver::nfglIndexPointerEXT (GLenum a, GLsizei b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glIndexPointerEXT"));
	fn.glIndexPointerEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalPointerEXT (GLenum a, GLsizei b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glNormalPointerEXT"));
	fn.glNormalPointerEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglTexCoordPointerEXT (GLint a, GLenum b, GLsizei c, GLsizei d, const GLvoid * e)
{
	D(bug("nfosmesa: glTexCoordPointerEXT"));
	fn.glTexCoordPointerEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexPointerEXT (GLint a, GLenum b, GLsizei c, GLsizei d, const GLvoid * e)
{
	D(bug("nfosmesa: glVertexPointerEXT"));
	fn.glVertexPointerEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglBlendEquationEXT (GLenum a)
{
	D(bug("nfosmesa: glBlendEquationEXT"));
	fn.glBlendEquationEXT ( a);
}

void OSMesaDriver::nfglSpriteParameterfSGIX (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glSpriteParameterfSGIX"));
	fn.glSpriteParameterfSGIX ( a,  b);
}

void OSMesaDriver::nfglSpriteParameterfvSGIX (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glSpriteParameterfvSGIX"));
	fn.glSpriteParameterfvSGIX ( a,  b);
}

void OSMesaDriver::nfglSpriteParameteriSGIX (GLenum a, GLint b)
{
	D(bug("nfosmesa: glSpriteParameteriSGIX"));
	fn.glSpriteParameteriSGIX ( a,  b);
}

void OSMesaDriver::nfglSpriteParameterivSGIX (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glSpriteParameterivSGIX"));
	fn.glSpriteParameterivSGIX ( a,  b);
}

void OSMesaDriver::nfglPointParameterfEXT (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPointParameterfEXT"));
	fn.glPointParameterfEXT ( a,  b);
}

void OSMesaDriver::nfglPointParameterfvEXT (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glPointParameterfvEXT"));
	fn.glPointParameterfvEXT ( a,  b);
}

void OSMesaDriver::nfglPointParameterfSGIS (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPointParameterfSGIS"));
	fn.glPointParameterfSGIS ( a,  b);
}

void OSMesaDriver::nfglPointParameterfvSGIS (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glPointParameterfvSGIS"));
	fn.glPointParameterfvSGIS ( a,  b);
}

GLint OSMesaDriver::nfglGetInstrumentsSGIX (void)
{
	D(bug("nfosmesa: glGetInstrumentsSGIX"));
	return fn.glGetInstrumentsSGIX ();
}

void OSMesaDriver::nfglInstrumentsBufferSGIX (GLsizei a, GLint * b)
{
	D(bug("nfosmesa: glInstrumentsBufferSGIX"));
	fn.glInstrumentsBufferSGIX ( a,  b);
}

GLint OSMesaDriver::nfglPollInstrumentsSGIX (GLint * a)
{
	D(bug("nfosmesa: glPollInstrumentsSGIX"));
	return fn.glPollInstrumentsSGIX ( a);
}

void OSMesaDriver::nfglReadInstrumentsSGIX (GLint a)
{
	D(bug("nfosmesa: glReadInstrumentsSGIX"));
	fn.glReadInstrumentsSGIX ( a);
}

void OSMesaDriver::nfglStartInstrumentsSGIX (void)
{
	D(bug("nfosmesa: glStartInstrumentsSGIX"));
	fn.glStartInstrumentsSGIX ();
}

void OSMesaDriver::nfglStopInstrumentsSGIX (GLint a)
{
	D(bug("nfosmesa: glStopInstrumentsSGIX"));
	fn.glStopInstrumentsSGIX ( a);
}

void OSMesaDriver::nfglFrameZoomSGIX (GLint a)
{
	D(bug("nfosmesa: glFrameZoomSGIX"));
	fn.glFrameZoomSGIX ( a);
}

void OSMesaDriver::nfglTagSampleBufferSGIX (void )
{
	D(bug("nfosmesa: glTagSampleBufferSGIX"));
	fn.glTagSampleBufferSGIX ();
}

void OSMesaDriver::nfglDeformationMap3dSGIX (GLenum a, GLdouble b, GLdouble c, GLint d, GLint e, GLdouble f, GLdouble g, GLint h, GLint i, GLdouble j, GLdouble k, GLint l, GLint m, const GLdouble * n)
{
	D(bug("nfosmesa: glDeformationMap3dSGIX"));
	fn.glDeformationMap3dSGIX ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m,  n);
}

void OSMesaDriver::nfglDeformationMap3fSGIX (GLenum a, GLfloat b, GLfloat c, GLint d, GLint e, GLfloat f, GLfloat g, GLint h, GLint i, GLfloat j, GLfloat k, GLint l, GLint m, const GLfloat * n)
{
	D(bug("nfosmesa: glDeformationMap3fSGIX"));
	fn.glDeformationMap3fSGIX ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m,  n);
}

void OSMesaDriver::nfglDeformSGIX (GLbitfield a)
{
	D(bug("nfosmesa: glDeformSGIX"));
	fn.glDeformSGIX ( a);
}

void OSMesaDriver::nfglLoadIdentityDeformationMapSGIX (GLbitfield a)
{
	D(bug("nfosmesa: glLoadIdentityDeformationMapSGIX"));
	fn.glLoadIdentityDeformationMapSGIX ( a);
}

void OSMesaDriver::nfglReferencePlaneSGIX (const GLdouble * a)
{
	D(bug("nfosmesa: glReferencePlaneSGIX"));
	fn.glReferencePlaneSGIX ( a);
}

void OSMesaDriver::nfglFlushRasterSGIX (void )
{
	D(bug("nfosmesa: glFlushRasterSGIX"));
	fn.glFlushRasterSGIX ();
}

void OSMesaDriver::nfglFogFuncSGIS (GLsizei a, const GLfloat * b)
{
	D(bug("nfosmesa: glFogFuncSGIS"));
	fn.glFogFuncSGIS ( a,  b);
}

void OSMesaDriver::nfglGetFogFuncSGIS (GLfloat * a)
{
	D(bug("nfosmesa: glGetFogFuncSGIS"));
	fn.glGetFogFuncSGIS ( a);
}

void OSMesaDriver::nfglImageTransformParameteriHP (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glImageTransformParameteriHP"));
	fn.glImageTransformParameteriHP ( a,  b,  c);
}

void OSMesaDriver::nfglImageTransformParameterfHP (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glImageTransformParameterfHP"));
	fn.glImageTransformParameterfHP ( a,  b,  c);
}

void OSMesaDriver::nfglImageTransformParameterivHP (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glImageTransformParameterivHP"));
	fn.glImageTransformParameterivHP ( a,  b,  c);
}

void OSMesaDriver::nfglImageTransformParameterfvHP (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glImageTransformParameterfvHP"));
	fn.glImageTransformParameterfvHP ( a,  b,  c);
}

void OSMesaDriver::nfglGetImageTransformParameterivHP (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetImageTransformParameterivHP"));
	fn.glGetImageTransformParameterivHP ( a,  b,  c);
}

void OSMesaDriver::nfglGetImageTransformParameterfvHP (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetImageTransformParameterfvHP"));
	fn.glGetImageTransformParameterfvHP ( a,  b,  c);
}

void OSMesaDriver::nfglColorSubTableEXT (GLenum a, GLsizei b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glColorSubTableEXT"));
	fn.glColorSubTableEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglCopyColorSubTableEXT (GLenum a, GLsizei b, GLint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glCopyColorSubTableEXT"));
	fn.glCopyColorSubTableEXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglHintPGI (GLenum a, GLint b)
{
	D(bug("nfosmesa: glHintPGI"));
	fn.glHintPGI ( a,  b);
}

void OSMesaDriver::nfglColorTableEXT (GLenum a, GLenum b, GLsizei c, GLenum d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glColorTableEXT"));
	fn.glColorTableEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglGetColorTableEXT (GLenum a, GLenum b, GLenum c, GLvoid * d)
{
	D(bug("nfosmesa: glGetColorTableEXT"));
	fn.glGetColorTableEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetColorTableParameterivEXT (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetColorTableParameterivEXT"));
	fn.glGetColorTableParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetColorTableParameterfvEXT (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetColorTableParameterfvEXT"));
	fn.glGetColorTableParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetListParameterfvSGIX (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetListParameterfvSGIX"));
	fn.glGetListParameterfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglGetListParameterivSGIX (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetListParameterivSGIX"));
	fn.glGetListParameterivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglListParameterfSGIX (GLuint a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glListParameterfSGIX"));
	fn.glListParameterfSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglListParameterfvSGIX (GLuint a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glListParameterfvSGIX"));
	fn.glListParameterfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglListParameteriSGIX (GLuint a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glListParameteriSGIX"));
	fn.glListParameteriSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglListParameterivSGIX (GLuint a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glListParameterivSGIX"));
	fn.glListParameterivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglIndexMaterialEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glIndexMaterialEXT"));
	fn.glIndexMaterialEXT ( a,  b);
}

void OSMesaDriver::nfglIndexFuncEXT (GLenum a, GLclampf b)
{
	D(bug("nfosmesa: glIndexFuncEXT"));
	fn.glIndexFuncEXT ( a,  b);
}

void OSMesaDriver::nfglLockArraysEXT (GLint a, GLsizei b)
{
	D(bug("nfosmesa: glLockArraysEXT"));
	fn.glLockArraysEXT ( a,  b);
}

void OSMesaDriver::nfglUnlockArraysEXT (void )
{
	D(bug("nfosmesa: glUnlockArraysEXT"));
	fn.glUnlockArraysEXT ();
}

void OSMesaDriver::nfglCullParameterdvEXT (GLenum a, GLdouble * b)
{
	D(bug("nfosmesa: glCullParameterdvEXT"));
	fn.glCullParameterdvEXT ( a,  b);
}

void OSMesaDriver::nfglCullParameterfvEXT (GLenum a, GLfloat * b)
{
	D(bug("nfosmesa: glCullParameterfvEXT"));
	fn.glCullParameterfvEXT ( a,  b);
}

void OSMesaDriver::nfglFragmentColorMaterialSGIX (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glFragmentColorMaterialSGIX"));
	fn.glFragmentColorMaterialSGIX ( a,  b);
}

void OSMesaDriver::nfglFragmentLightfSGIX (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glFragmentLightfSGIX"));
	fn.glFragmentLightfSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentLightfvSGIX (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glFragmentLightfvSGIX"));
	fn.glFragmentLightfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentLightiSGIX (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glFragmentLightiSGIX"));
	fn.glFragmentLightiSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentLightivSGIX (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glFragmentLightivSGIX"));
	fn.glFragmentLightivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentLightModelfSGIX (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glFragmentLightModelfSGIX"));
	fn.glFragmentLightModelfSGIX ( a,  b);
}

void OSMesaDriver::nfglFragmentLightModelfvSGIX (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glFragmentLightModelfvSGIX"));
	fn.glFragmentLightModelfvSGIX ( a,  b);
}

void OSMesaDriver::nfglFragmentLightModeliSGIX (GLenum a, GLint b)
{
	D(bug("nfosmesa: glFragmentLightModeliSGIX"));
	fn.glFragmentLightModeliSGIX ( a,  b);
}

void OSMesaDriver::nfglFragmentLightModelivSGIX (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glFragmentLightModelivSGIX"));
	fn.glFragmentLightModelivSGIX ( a,  b);
}

void OSMesaDriver::nfglFragmentMaterialfSGIX (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glFragmentMaterialfSGIX"));
	fn.glFragmentMaterialfSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentMaterialfvSGIX (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glFragmentMaterialfvSGIX"));
	fn.glFragmentMaterialfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentMaterialiSGIX (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glFragmentMaterialiSGIX"));
	fn.glFragmentMaterialiSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglFragmentMaterialivSGIX (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glFragmentMaterialivSGIX"));
	fn.glFragmentMaterialivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglGetFragmentLightfvSGIX (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetFragmentLightfvSGIX"));
	fn.glGetFragmentLightfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglGetFragmentLightivSGIX (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetFragmentLightivSGIX"));
	fn.glGetFragmentLightivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglGetFragmentMaterialfvSGIX (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetFragmentMaterialfvSGIX"));
	fn.glGetFragmentMaterialfvSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglGetFragmentMaterialivSGIX (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetFragmentMaterialivSGIX"));
	fn.glGetFragmentMaterialivSGIX ( a,  b,  c);
}

void OSMesaDriver::nfglLightEnviSGIX (GLenum a, GLint b)
{
	D(bug("nfosmesa: glLightEnviSGIX"));
	fn.glLightEnviSGIX ( a,  b);
}

void OSMesaDriver::nfglDrawRangeElementsEXT (GLenum a, GLuint b, GLuint c, GLsizei d, GLenum e, const GLvoid * f)
{
	D(bug("nfosmesa: glDrawRangeElementsEXT"));
	fn.glDrawRangeElementsEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglApplyTextureEXT (GLenum a)
{
	D(bug("nfosmesa: glApplyTextureEXT"));
	fn.glApplyTextureEXT ( a);
}

void OSMesaDriver::nfglTextureLightEXT (GLenum a)
{
	D(bug("nfosmesa: glTextureLightEXT"));
	fn.glTextureLightEXT ( a);
}

void OSMesaDriver::nfglTextureMaterialEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glTextureMaterialEXT"));
	fn.glTextureMaterialEXT ( a,  b);
}

void OSMesaDriver::nfglAsyncMarkerSGIX (GLuint a)
{
	D(bug("nfosmesa: glAsyncMarkerSGIX"));
	fn.glAsyncMarkerSGIX ( a);
}

GLint OSMesaDriver::nfglFinishAsyncSGIX (GLuint * a)
{
	D(bug("nfosmesa: glFinishAsyncSGIX"));
	return fn.glFinishAsyncSGIX ( a);
}

GLint OSMesaDriver::nfglPollAsyncSGIX (GLuint * a)
{
	D(bug("nfosmesa: glPollAsyncSGIX"));
	return fn.glPollAsyncSGIX ( a);
}

GLuint OSMesaDriver::nfglGenAsyncMarkersSGIX (GLsizei a)
{
	D(bug("nfosmesa: glGenAsyncMarkersSGIX"));
	return fn.glGenAsyncMarkersSGIX ( a);
}

void OSMesaDriver::nfglDeleteAsyncMarkersSGIX (GLuint a, GLsizei b)
{
	D(bug("nfosmesa: glDeleteAsyncMarkersSGIX"));
	fn.glDeleteAsyncMarkersSGIX ( a,  b);
}

GLboolean OSMesaDriver::nfglIsAsyncMarkerSGIX (GLuint a)
{
	D(bug("nfosmesa: glIsAsyncMarkerSGIX"));
	return fn.glIsAsyncMarkerSGIX ( a);
}

void OSMesaDriver::nfglVertexPointervINTEL (GLint a, GLenum b, const GLvoid* * c)
{
	D(bug("nfosmesa: glVertexPointervINTEL"));
	fn.glVertexPointervINTEL ( a,  b, c);
}

void OSMesaDriver::nfglNormalPointervINTEL (GLenum a, const GLvoid* * b)
{
	D(bug("nfosmesa: glNormalPointervINTEL"));
	fn.glNormalPointervINTEL ( a, b);
}

void OSMesaDriver::nfglColorPointervINTEL (GLint a, GLenum b, const GLvoid* * c)
{
	D(bug("nfosmesa: glColorPointervINTEL"));
	fn.glColorPointervINTEL ( a,  b, c);
}

void OSMesaDriver::nfglTexCoordPointervINTEL (GLint a, GLenum b, const GLvoid* * c)
{
	D(bug("nfosmesa: glTexCoordPointervINTEL"));
	fn.glTexCoordPointervINTEL ( a,  b, c);
}

void OSMesaDriver::nfglPixelTransformParameteriEXT (GLenum a, GLenum b, GLint c)
{
	D(bug("nfosmesa: glPixelTransformParameteriEXT"));
	fn.glPixelTransformParameteriEXT ( a,  b,  c);
}

void OSMesaDriver::nfglPixelTransformParameterfEXT (GLenum a, GLenum b, GLfloat c)
{
	D(bug("nfosmesa: glPixelTransformParameterfEXT"));
	fn.glPixelTransformParameterfEXT ( a,  b,  c);
}

void OSMesaDriver::nfglPixelTransformParameterivEXT (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glPixelTransformParameterivEXT"));
	fn.glPixelTransformParameterivEXT ( a,  b,  c);
}

void OSMesaDriver::nfglPixelTransformParameterfvEXT (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glPixelTransformParameterfvEXT"));
	fn.glPixelTransformParameterfvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3bEXT (GLbyte a, GLbyte b, GLbyte c)
{
	D(bug("nfosmesa: glSecondaryColor3bEXT"));
	fn.glSecondaryColor3bEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3bvEXT (const GLbyte * a)
{
	D(bug("nfosmesa: glSecondaryColor3bvEXT"));
	fn.glSecondaryColor3bvEXT ( a);
}

void OSMesaDriver::nfglSecondaryColor3dEXT (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glSecondaryColor3dEXT"));
	fn.glSecondaryColor3dEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3dvEXT (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glSecondaryColor3dvEXT"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3dvEXT ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3fEXT (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glSecondaryColor3fEXT"));
	fn.glSecondaryColor3fEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3fvEXT (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glSecondaryColor3fvEXT"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3fvEXT ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3iEXT (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glSecondaryColor3iEXT"));
	fn.glSecondaryColor3iEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3ivEXT (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glSecondaryColor3ivEXT"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3ivEXT ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3sEXT (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glSecondaryColor3sEXT"));
	fn.glSecondaryColor3sEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3svEXT (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glSecondaryColor3svEXT"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glSecondaryColor3svEXT ( tmp);
}

void OSMesaDriver::nfglSecondaryColor3ubEXT (GLubyte a, GLubyte b, GLubyte c)
{
	D(bug("nfosmesa: glSecondaryColor3ubEXT"));
	fn.glSecondaryColor3ubEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3ubvEXT (const GLubyte * a)
{
	D(bug("nfosmesa: glSecondaryColor3ubvEXT"));
	fn.glSecondaryColor3ubvEXT ( a);
}

void OSMesaDriver::nfglSecondaryColor3uiEXT (GLuint a, GLuint b, GLuint c)
{
	D(bug("nfosmesa: glSecondaryColor3uiEXT"));
	fn.glSecondaryColor3uiEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3uivEXT (const GLuint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glSecondaryColor3uivEXT"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glSecondaryColor3uivEXT ( (GLuint *)tmp);
}

void OSMesaDriver::nfglSecondaryColor3usEXT (GLushort a, GLushort b, GLushort c)
{
	D(bug("nfosmesa: glSecondaryColor3usEXT"));
	fn.glSecondaryColor3usEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3usvEXT (const GLushort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glSecondaryColor3usvEXT"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glSecondaryColor3usvEXT ( (GLushort *)tmp);
}

void OSMesaDriver::nfglSecondaryColorPointerEXT (GLint a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glSecondaryColorPointerEXT"));
	fn.glSecondaryColorPointerEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglTextureNormalEXT (GLenum a)
{
	D(bug("nfosmesa: glTextureNormalEXT"));
	fn.glTextureNormalEXT ( a);
}

void OSMesaDriver::nfglMultiDrawArraysEXT (GLenum a, GLint * b, GLsizei * c, GLsizei d)
{
	D(bug("nfosmesa: glMultiDrawArraysEXT"));
	fn.glMultiDrawArraysEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiDrawElementsEXT (GLenum a, const GLsizei * b, GLenum c, const GLvoid* * d, GLsizei e)
{
	D(bug("nfosmesa: glMultiDrawElementsEXT"));
	fn.glMultiDrawElementsEXT ( a,  b,  c, d,  e);
}

void OSMesaDriver::nfglFogCoordfEXT (GLfloat a)
{
	D(bug("nfosmesa: glFogCoordfEXT"));
	fn.glFogCoordfEXT ( a);
}

void OSMesaDriver::nfglFogCoordfvEXT (const GLfloat * a)
{
	D(bug("nfosmesa: glFogCoordfvEXT"));
	fn.glFogCoordfvEXT ( a);
}

void OSMesaDriver::nfglFogCoorddEXT (GLdouble a)
{
	D(bug("nfosmesa: glFogCoorddEXT"));
	fn.glFogCoorddEXT ( a);
}

void OSMesaDriver::nfglFogCoorddvEXT (const GLdouble * a)
{
	D(bug("nfosmesa: glFogCoorddvEXT"));
	fn.glFogCoorddvEXT ( a);
}

void OSMesaDriver::nfglFogCoordPointerEXT (GLenum a, GLsizei b, const GLvoid * c)
{
	D(bug("nfosmesa: glFogCoordPointerEXT"));
	fn.glFogCoordPointerEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3bEXT (GLbyte a, GLbyte b, GLbyte c)
{
	D(bug("nfosmesa: glTangent3bEXT"));
	fn.glTangent3bEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3bvEXT (const GLbyte * a)
{
	D(bug("nfosmesa: glTangent3bvEXT"));
	fn.glTangent3bvEXT ( a);
}

void OSMesaDriver::nfglTangent3dEXT (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glTangent3dEXT"));
	fn.glTangent3dEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3dvEXT (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glTangent3dvEXT"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glTangent3dvEXT ( tmp);
}

void OSMesaDriver::nfglTangent3fEXT (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glTangent3fEXT"));
	fn.glTangent3fEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3fvEXT (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glTangent3fvEXT"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glTangent3fvEXT ( tmp);
}

void OSMesaDriver::nfglTangent3iEXT (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glTangent3iEXT"));
	fn.glTangent3iEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3ivEXT (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glTangent3ivEXT"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glTangent3ivEXT ( tmp);
}

void OSMesaDriver::nfglTangent3sEXT (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glTangent3sEXT"));
	fn.glTangent3sEXT ( a,  b,  c);
}

void OSMesaDriver::nfglTangent3svEXT (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glTangent3svEXT"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glTangent3svEXT ( tmp);
}

void OSMesaDriver::nfglBinormal3bEXT (GLbyte a, GLbyte b, GLbyte c)
{
	D(bug("nfosmesa: glBinormal3bEXT"));
	fn.glBinormal3bEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormal3bvEXT (const GLbyte * a)
{
	D(bug("nfosmesa: glBinormal3bvEXT"));
	fn.glBinormal3bvEXT ( a);
}

void OSMesaDriver::nfglBinormal3dEXT (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glBinormal3dEXT"));
	fn.glBinormal3dEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormal3dvEXT (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glBinormal3dvEXT"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glBinormal3dvEXT ( tmp);
}

void OSMesaDriver::nfglBinormal3fEXT (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glBinormal3fEXT"));
	fn.glBinormal3fEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormal3fvEXT (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glBinormal3fvEXT"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glBinormal3fvEXT ( tmp);
}

void OSMesaDriver::nfglBinormal3iEXT (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glBinormal3iEXT"));
	fn.glBinormal3iEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormal3ivEXT (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glBinormal3ivEXT"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glBinormal3ivEXT ( tmp);
}

void OSMesaDriver::nfglBinormal3sEXT (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glBinormal3sEXT"));
	fn.glBinormal3sEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormal3svEXT (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glBinormal3svEXT"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glBinormal3svEXT ( tmp);
}

void OSMesaDriver::nfglTangentPointerEXT (GLenum a, GLsizei b, const GLvoid * c)
{
	D(bug("nfosmesa: glTangentPointerEXT"));
	fn.glTangentPointerEXT ( a,  b,  c);
}

void OSMesaDriver::nfglBinormalPointerEXT (GLenum a, GLsizei b, const GLvoid * c)
{
	D(bug("nfosmesa: glBinormalPointerEXT"));
	fn.glBinormalPointerEXT ( a,  b,  c);
}

void OSMesaDriver::nfglFinishTextureSUNX (void )
{
	D(bug("nfosmesa: glFinishTextureSUNX"));
	fn.glFinishTextureSUNX ();
}

void OSMesaDriver::nfglGlobalAlphaFactorbSUN (GLbyte a)
{
	D(bug("nfosmesa: glGlobalAlphaFactorbSUN"));
	fn.glGlobalAlphaFactorbSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactorsSUN (GLshort a)
{
	D(bug("nfosmesa: glGlobalAlphaFactorsSUN"));
	fn.glGlobalAlphaFactorsSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactoriSUN (GLint a)
{
	D(bug("nfosmesa: glGlobalAlphaFactoriSUN"));
	fn.glGlobalAlphaFactoriSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactorfSUN (GLfloat a)
{
	D(bug("nfosmesa: glGlobalAlphaFactorfSUN"));
	fn.glGlobalAlphaFactorfSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactordSUN (GLdouble a)
{
	D(bug("nfosmesa: glGlobalAlphaFactordSUN"));
	fn.glGlobalAlphaFactordSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactorubSUN (GLubyte a)
{
	D(bug("nfosmesa: glGlobalAlphaFactorubSUN"));
	fn.glGlobalAlphaFactorubSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactorusSUN (GLushort a)
{
	D(bug("nfosmesa: glGlobalAlphaFactorusSUN"));
	fn.glGlobalAlphaFactorusSUN ( a);
}

void OSMesaDriver::nfglGlobalAlphaFactoruiSUN (GLuint a)
{
	D(bug("nfosmesa: glGlobalAlphaFactoruiSUN"));
	fn.glGlobalAlphaFactoruiSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeuiSUN (GLuint a)
{
	D(bug("nfosmesa: glReplacementCodeuiSUN"));
	fn.glReplacementCodeuiSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeusSUN (GLushort a)
{
	D(bug("nfosmesa: glReplacementCodeusSUN"));
	fn.glReplacementCodeusSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeubSUN (GLubyte a)
{
	D(bug("nfosmesa: glReplacementCodeubSUN"));
	fn.glReplacementCodeubSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeuivSUN (const GLuint * a)
{
	D(bug("nfosmesa: glReplacementCodeuivSUN"));
	fn.glReplacementCodeuivSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeusvSUN (const GLushort * a)
{
	D(bug("nfosmesa: glReplacementCodeusvSUN"));
	fn.glReplacementCodeusvSUN ( a);
}

void OSMesaDriver::nfglReplacementCodeubvSUN (const GLubyte * a)
{
	D(bug("nfosmesa: glReplacementCodeubvSUN"));
	fn.glReplacementCodeubvSUN ( a);
}

void OSMesaDriver::nfglReplacementCodePointerSUN (GLenum a, GLsizei b, const GLvoid* * c)
{
	D(bug("nfosmesa: glReplacementCodePointerSUN"));
	fn.glReplacementCodePointerSUN ( a,  b, c);
}

void OSMesaDriver::nfglColor4ubVertex2fSUN (GLubyte a, GLubyte b, GLubyte c, GLubyte d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glColor4ubVertex2fSUN"));
	fn.glColor4ubVertex2fSUN ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglColor4ubVertex2fvSUN (const GLubyte * a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glColor4ubVertex2fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glColor4ubVertex2fvSUN ( a, tmp);
}

void OSMesaDriver::nfglColor4ubVertex3fSUN (GLubyte a, GLubyte b, GLubyte c, GLubyte d, GLfloat e, GLfloat f, GLfloat g)
{
	D(bug("nfosmesa: glColor4ubVertex3fSUN"));
	fn.glColor4ubVertex3fSUN ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglColor4ubVertex3fvSUN (const GLubyte * a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glColor4ubVertex3fvSUN"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glColor4ubVertex3fvSUN ( a, tmp);
}

void OSMesaDriver::nfglColor3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glColor3fVertex3fSUN"));
	fn.glColor3fVertex3fSUN ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglColor3fVertex3fvSUN (const GLfloat * a, const GLfloat * b)
{
	GLfloat tmp1[3],tmp2[3];

	D(bug("nfosmesa: glColor3fVertex3fvSUN"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	fn.glColor3fVertex3fvSUN ( tmp1, tmp2);
}

void OSMesaDriver::nfglNormal3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glNormal3fVertex3fSUN"));
	fn.glNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglNormal3fVertex3fvSUN (const GLfloat * a, const GLfloat * b)
{
	GLfloat tmp1[3],tmp2[3];

	D(bug("nfosmesa: glNormal3fVertex3fvSUN"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	fn.glNormal3fVertex3fvSUN ( tmp1, tmp2);
}

void OSMesaDriver::nfglColor4fNormal3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i, GLfloat j)
{
	D(bug("nfosmesa: glColor4fNormal3fVertex3fSUN"));
	fn.glColor4fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j);
}

void OSMesaDriver::nfglColor4fNormal3fVertex3fvSUN (const GLfloat * a, const GLfloat * b, const GLfloat * c)
{
	GLfloat tmp1[4],tmp2[3],tmp3[3];

	D(bug("nfosmesa: glColor4fNormal3fVertex3fvSUN"));
	Atari2HostFloatPtr(4, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp3);
	fn.glColor4fNormal3fVertex3fvSUN ( tmp1, tmp2, tmp3);
}

void OSMesaDriver::nfglTexCoord2fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glTexCoord2fVertex3fSUN"));
	fn.glTexCoord2fVertex3fSUN ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglTexCoord2fVertex3fvSUN (const GLfloat * a, const GLfloat * b)
{
	GLfloat tmp1[2],tmp2[3];

	D(bug("nfosmesa: glTexCoord2fVertex3fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	fn.glTexCoord2fVertex3fvSUN ( tmp1, tmp2);
}

void OSMesaDriver::nfglTexCoord4fVertex4fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h)
{
	D(bug("nfosmesa: glTexCoord4fVertex4fSUN"));
	fn.glTexCoord4fVertex4fSUN ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglTexCoord4fVertex4fvSUN (const GLfloat * a, const GLfloat * b)
{
	GLfloat tmp1[4],tmp2[4];

	D(bug("nfosmesa: glTexCoord4fVertex4fvSUN"));
	Atari2HostFloatPtr(4, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp2);
	fn.glTexCoord4fVertex4fvSUN ( tmp1, tmp2);
}

void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fSUN (GLfloat a, GLfloat b, GLubyte c, GLubyte d, GLubyte e, GLubyte f, GLfloat g, GLfloat h, GLfloat i)
{
	D(bug("nfosmesa: glTexCoord2fColor4ubVertex3fSUN"));
	fn.glTexCoord2fColor4ubVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fvSUN (const GLfloat * a, const GLubyte * b, const GLfloat * c)
{
	GLfloat tmp1[2],tmp2[3];

	D(bug("nfosmesa: glTexCoord2fColor4ubVertex3fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp2);
	fn.glTexCoord2fColor4ubVertex3fvSUN ( tmp1,  b, tmp2);
}

void OSMesaDriver::nfglTexCoord2fColor3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h)
{
	D(bug("nfosmesa: glTexCoord2fColor3fVertex3fSUN"));
	fn.glTexCoord2fColor3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglTexCoord2fColor3fVertex3fvSUN (const GLfloat * a, const GLfloat * b, const GLfloat * c)
{
	GLfloat tmp1[2],tmp2[3],tmp3[3];

	D(bug("nfosmesa: glTexCoord2fColor3fVertex3fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp3);
	fn.glTexCoord2fColor3fVertex3fvSUN ( tmp1, tmp2, tmp3);
}

void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h)
{
	D(bug("nfosmesa: glTexCoord2fNormal3fVertex3fSUN"));
	fn.glTexCoord2fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fvSUN (const GLfloat * a, const GLfloat * b, const GLfloat * c)
{
	GLfloat tmp1[2],tmp2[3],tmp3[3];

	D(bug("nfosmesa: glTexCoord2fNormal3fVertex3fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp2);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp3);
	fn.glTexCoord2fNormal3fVertex3fvSUN ( tmp1, tmp2, tmp3);
}

void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i, GLfloat j, GLfloat k, GLfloat l)
{
	D(bug("nfosmesa: glTexCoord2fColor4fNormal3fVertex3fSUN"));
	fn.glTexCoord2fColor4fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l);
}

void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat * a, const GLfloat * b, const GLfloat * c, const GLfloat * d)
{
	GLfloat tmp1[2],tmp2[4],tmp3[3],tmp4[3];

	D(bug("nfosmesa: glTexCoord2fColor4fNormal3fVertex3fvSUN"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp2);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp3);
	Atari2HostFloatPtr(3, (Uint32 *)d, tmp4);
	fn.glTexCoord2fColor4fNormal3fVertex3fvSUN ( tmp1, tmp2, tmp3, tmp4);
}

void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i, GLfloat j, GLfloat k, GLfloat l, GLfloat m, GLfloat n, GLfloat o)
{
	D(bug("nfosmesa: glTexCoord4fColor4fNormal3fVertex4fSUN"));
	fn.glTexCoord4fColor4fNormal3fVertex4fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m,  n,  o);
}

void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat * a, const GLfloat * b, const GLfloat * c, const GLfloat * d)
{
	GLfloat tmp1[4],tmp2[4],tmp3[3],tmp4[4];

	D(bug("nfosmesa: glTexCoord4fColor4fNormal3fVertex4fvSUN"));
	Atari2HostFloatPtr(4, (Uint32 *)a, tmp1);
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp2);
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp3);
	Atari2HostFloatPtr(4, (Uint32 *)d, tmp4);
	fn.glTexCoord4fColor4fNormal3fVertex4fvSUN ( tmp1, tmp2, tmp3, tmp4);
}

void OSMesaDriver::nfglReplacementCodeuiVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glReplacementCodeuiVertex3fSUN"));
	fn.glReplacementCodeuiVertex3fSUN ( a,  b,  c,  d);
}

void OSMesaDriver::nfglReplacementCodeuiVertex3fvSUN (const GLuint * a, const GLfloat * b)
{
	D(bug("nfosmesa: glReplacementCodeuiVertex3fvSUN"));
	fn.glReplacementCodeuiVertex3fvSUN ( a,  b);
}

void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fSUN (GLuint a, GLubyte b, GLubyte c, GLubyte d, GLubyte e, GLfloat f, GLfloat g, GLfloat h)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4ubVertex3fSUN"));
	fn.glReplacementCodeuiColor4ubVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h);
}

void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fvSUN (const GLuint * a, const GLubyte * b, const GLfloat * c)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4ubVertex3fvSUN"));
	fn.glReplacementCodeuiColor4ubVertex3fvSUN ( a,  b,  c);
}

void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g)
{
	D(bug("nfosmesa: glReplacementCodeuiColor3fVertex3fSUN"));
	fn.glReplacementCodeuiColor3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c)
{
	D(bug("nfosmesa: glReplacementCodeuiColor3fVertex3fvSUN"));
	fn.glReplacementCodeuiColor3fVertex3fvSUN ( a,  b,  c);
}

void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g)
{
	D(bug("nfosmesa: glReplacementCodeuiNormal3fVertex3fSUN"));
	fn.glReplacementCodeuiNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c)
{
	D(bug("nfosmesa: glReplacementCodeuiNormal3fVertex3fvSUN"));
	fn.glReplacementCodeuiNormal3fVertex3fvSUN ( a,  b,  c);
}

void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i, GLfloat j, GLfloat k)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4fNormal3fVertex3fSUN"));
	fn.glReplacementCodeuiColor4fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k);
}

void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c, const GLfloat * d)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4fNormal3fVertex3fvSUN"));
	fn.glReplacementCodeuiColor4fNormal3fVertex3fvSUN ( a,  b,  c,  d);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fVertex3fSUN"));
	fn.glReplacementCodeuiTexCoord2fVertex3fSUN ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fVertex3fvSUN"));
	fn.glReplacementCodeuiTexCoord2fVertex3fvSUN ( a,  b,  c);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN"));
	fn.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c, const GLfloat * d)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN"));
	fn.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN ( a,  b,  c,  d);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e, GLfloat f, GLfloat g, GLfloat h, GLfloat i, GLfloat j, GLfloat k, GLfloat l, GLfloat m)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN"));
	fn.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint * a, const GLfloat * b, const GLfloat * c, const GLfloat * d, const GLfloat * e)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN"));
	fn.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglBlendFuncSeparateEXT (GLenum a, GLenum b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glBlendFuncSeparateEXT"));
	fn.glBlendFuncSeparateEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglBlendFuncSeparateINGR (GLenum a, GLenum b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glBlendFuncSeparateINGR"));
	fn.glBlendFuncSeparateINGR ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexWeightfEXT (GLfloat a)
{
	D(bug("nfosmesa: glVertexWeightfEXT"));
	fn.glVertexWeightfEXT ( a);
}

void OSMesaDriver::nfglVertexWeightfvEXT (const GLfloat * a)
{
	D(bug("nfosmesa: glVertexWeightfvEXT"));
	fn.glVertexWeightfvEXT ( a);
}

void OSMesaDriver::nfglVertexWeightPointerEXT (GLsizei a, GLenum b, GLsizei c, const GLvoid * d)
{
	D(bug("nfosmesa: glVertexWeightPointerEXT"));
	fn.glVertexWeightPointerEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglFlushVertexArrayRangeNV (void )
{
	D(bug("nfosmesa: glFlushVertexArrayRangeNV"));
	fn.glFlushVertexArrayRangeNV ();
}

void OSMesaDriver::nfglVertexArrayRangeNV (GLsizei a, const GLvoid * b)
{
	D(bug("nfosmesa: glVertexArrayRangeNV"));
	fn.glVertexArrayRangeNV ( a,  b);
}

void OSMesaDriver::nfglCombinerParameterfvNV (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glCombinerParameterfvNV"));
	fn.glCombinerParameterfvNV ( a,  b);
}

void OSMesaDriver::nfglCombinerParameterfNV (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glCombinerParameterfNV"));
	fn.glCombinerParameterfNV ( a,  b);
}

void OSMesaDriver::nfglCombinerParameterivNV (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glCombinerParameterivNV"));
	fn.glCombinerParameterivNV ( a,  b);
}

void OSMesaDriver::nfglCombinerParameteriNV (GLenum a, GLint b)
{
	D(bug("nfosmesa: glCombinerParameteriNV"));
	fn.glCombinerParameteriNV ( a,  b);
}

void OSMesaDriver::nfglCombinerInputNV (GLenum a, GLenum b, GLenum c, GLenum d, GLenum e, GLenum f)
{
	D(bug("nfosmesa: glCombinerInputNV"));
	fn.glCombinerInputNV ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglCombinerOutputNV (GLenum a, GLenum b, GLenum c, GLenum d, GLenum e, GLenum f, GLenum g, GLboolean h, GLboolean i, GLboolean j)
{
	D(bug("nfosmesa: glCombinerOutputNV"));
	fn.glCombinerOutputNV ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j);
}

void OSMesaDriver::nfglFinalCombinerInputNV (GLenum a, GLenum b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glFinalCombinerInputNV"));
	fn.glFinalCombinerInputNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetCombinerInputParameterfvNV (GLenum a, GLenum b, GLenum c, GLenum d, GLfloat * e)
{
	D(bug("nfosmesa: glGetCombinerInputParameterfvNV"));
	fn.glGetCombinerInputParameterfvNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetCombinerInputParameterivNV (GLenum a, GLenum b, GLenum c, GLenum d, GLint * e)
{
	D(bug("nfosmesa: glGetCombinerInputParameterivNV"));
	fn.glGetCombinerInputParameterivNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetCombinerOutputParameterfvNV (GLenum a, GLenum b, GLenum c, GLfloat * d)
{
	D(bug("nfosmesa: glGetCombinerOutputParameterfvNV"));
	fn.glGetCombinerOutputParameterfvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetCombinerOutputParameterivNV (GLenum a, GLenum b, GLenum c, GLint * d)
{
	D(bug("nfosmesa: glGetCombinerOutputParameterivNV"));
	fn.glGetCombinerOutputParameterivNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetFinalCombinerInputParameterfvNV (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterfvNV"));
	fn.glGetFinalCombinerInputParameterfvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetFinalCombinerInputParameterivNV (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterivNV"));
	fn.glGetFinalCombinerInputParameterivNV ( a,  b,  c);
}

void OSMesaDriver::nfglResizeBuffersMESA (void )
{
	D(bug("nfosmesa: glResizeBuffersMESA"));
	fn.glResizeBuffersMESA ();
}

void OSMesaDriver::nfglWindowPos2dMESA (GLdouble a, GLdouble b)
{
	D(bug("nfosmesa: glWindowPos2dMESA"));
	fn.glWindowPos2dMESA ( a,  b);
}

void OSMesaDriver::nfglWindowPos2dvMESA (const GLdouble * a)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glWindowPos2dvMESA"));
	Atari2HostDoublePtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2dvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos2fMESA (GLfloat a, GLfloat b)
{
	D(bug("nfosmesa: glWindowPos2fMESA"));
	fn.glWindowPos2fMESA ( a,  b);
}

void OSMesaDriver::nfglWindowPos2fvMESA (const GLfloat * a)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glWindowPos2fvMESA"));
	Atari2HostFloatPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2fvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos2iMESA (GLint a, GLint b)
{
	D(bug("nfosmesa: glWindowPos2iMESA"));
	fn.glWindowPos2iMESA ( a,  b);
}

void OSMesaDriver::nfglWindowPos2ivMESA (const GLint * a)
{
	GLint tmp[2];

	D(bug("nfosmesa: glWindowPos2ivMESA"));
	Atari2HostIntPtr(2, (Uint32 *)a, tmp);
	fn.glWindowPos2ivMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos2sMESA (GLshort a, GLshort b)
{
	D(bug("nfosmesa: glWindowPos2sMESA"));
	fn.glWindowPos2sMESA ( a,  b);
}

void OSMesaDriver::nfglWindowPos2svMESA (const GLshort * a)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glWindowPos2svMESA"));
	Atari2HostShortPtr(2, (Uint16 *)a, tmp);
	fn.glWindowPos2svMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos3dMESA (GLdouble a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glWindowPos3dMESA"));
	fn.glWindowPos3dMESA ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3dvMESA (const GLdouble * a)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glWindowPos3dvMESA"));
	Atari2HostDoublePtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3dvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos3fMESA (GLfloat a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glWindowPos3fMESA"));
	fn.glWindowPos3fMESA ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3fvMESA (const GLfloat * a)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glWindowPos3fvMESA"));
	Atari2HostFloatPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3fvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos3iMESA (GLint a, GLint b, GLint c)
{
	D(bug("nfosmesa: glWindowPos3iMESA"));
	fn.glWindowPos3iMESA ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3ivMESA (const GLint * a)
{
	GLint tmp[3];

	D(bug("nfosmesa: glWindowPos3ivMESA"));
	Atari2HostIntPtr(3, (Uint32 *)a, tmp);
	fn.glWindowPos3ivMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos3sMESA (GLshort a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glWindowPos3sMESA"));
	fn.glWindowPos3sMESA ( a,  b,  c);
}

void OSMesaDriver::nfglWindowPos3svMESA (const GLshort * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glWindowPos3svMESA"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glWindowPos3svMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos4dMESA (GLdouble a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glWindowPos4dMESA"));
	fn.glWindowPos4dMESA ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos4dvMESA (const GLdouble * a)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glWindowPos4dvMESA"));
	Atari2HostDoublePtr(4, (Uint32 *)a, tmp);
	fn.glWindowPos4dvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos4fMESA (GLfloat a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glWindowPos4fMESA"));
	fn.glWindowPos4fMESA ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos4fvMESA (const GLfloat * a)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glWindowPos4fvMESA"));
	Atari2HostFloatPtr(4, (Uint32 *)a, tmp);
	fn.glWindowPos4fvMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos4iMESA (GLint a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glWindowPos4iMESA"));
	fn.glWindowPos4iMESA ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos4ivMESA (const GLint * a)
{
	GLint tmp[4];

	D(bug("nfosmesa: glWindowPos4ivMESA"));
	Atari2HostIntPtr(4, (Uint32 *)a, tmp);
	fn.glWindowPos4ivMESA ( tmp);
}

void OSMesaDriver::nfglWindowPos4sMESA (GLshort a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glWindowPos4sMESA"));
	fn.glWindowPos4sMESA ( a,  b,  c,  d);
}

void OSMesaDriver::nfglWindowPos4svMESA (const GLshort * a)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glWindowPos4svMESA"));
	Atari2HostShortPtr(4, (Uint16 *)a, tmp);
	fn.glWindowPos4svMESA ( tmp);
}

void OSMesaDriver::nfglMultiModeDrawArraysIBM (const GLenum * a, const GLint * b, const GLsizei * c, GLsizei d, GLint e)
{
	D(bug("nfosmesa: glMultiModeDrawArraysIBM"));
	fn.glMultiModeDrawArraysIBM ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiModeDrawElementsIBM (const GLenum * a, const GLsizei * b, GLenum c, const GLvoid* const * f, GLsizei d, GLint e)
{
	D(bug("nfosmesa: glMultiModeDrawElementsIBM"));
	fn.glMultiModeDrawElementsIBM ( a,  b,  c, f,  d,  e);
}

void OSMesaDriver::nfglColorPointerListIBM (GLint a, GLenum b, GLint c, const GLvoid* * d, GLint e)
{
	D(bug("nfosmesa: glColorPointerListIBM"));
	fn.glColorPointerListIBM ( a,  b,  c, d,  e);
}

void OSMesaDriver::nfglSecondaryColorPointerListIBM (GLint a, GLenum b, GLint c, const GLvoid* * d, GLint e)
{
	D(bug("nfosmesa: glSecondaryColorPointerListIBM"));
	fn.glSecondaryColorPointerListIBM ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglEdgeFlagPointerListIBM (GLint a, const GLboolean* * b, GLint c)
{
	D(bug("nfosmesa: glEdgeFlagPointerListIBM"));
	fn.glEdgeFlagPointerListIBM ( a,  b,  c);
}

void OSMesaDriver::nfglFogCoordPointerListIBM (GLenum a, GLint b, const GLvoid* * c, GLint d)
{
	D(bug("nfosmesa: glFogCoordPointerListIBM"));
	fn.glFogCoordPointerListIBM ( a,  b, c,  d);
}

void OSMesaDriver::nfglIndexPointerListIBM (GLenum a, GLint b, const GLvoid* * c, GLint d)
{
	D(bug("nfosmesa: glIndexPointerListIBM"));
	fn.glIndexPointerListIBM ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalPointerListIBM (GLenum a, GLint b, const GLvoid* * c, GLint d)
{
	D(bug("nfosmesa: glNormalPointerListIBM"));
	fn.glNormalPointerListIBM ( a,  b, c,  d);
}

void OSMesaDriver::nfglTexCoordPointerListIBM (GLint a, GLenum b, GLint c, const GLvoid* * d, GLint e)
{
	D(bug("nfosmesa: glTexCoordPointerListIBM"));
	fn.glTexCoordPointerListIBM ( a,  b,  c, d,  e);
}

void OSMesaDriver::nfglVertexPointerListIBM (GLint a, GLenum b, GLint c, const GLvoid* * d, GLint e)
{
	D(bug("nfosmesa: glVertexPointerListIBM"));
	fn.glVertexPointerListIBM ( a,  b,  c, d,  e);
}

void OSMesaDriver::nfglTbufferMask3DFX (GLuint a)
{
	D(bug("nfosmesa: glTbufferMask3DFX"));
	fn.glTbufferMask3DFX ( a);
}

void OSMesaDriver::nfglSampleMaskEXT (GLclampf a, GLboolean b)
{
	D(bug("nfosmesa: glSampleMaskEXT"));
	fn.glSampleMaskEXT ( a,  b);
}

void OSMesaDriver::nfglSamplePatternEXT (GLenum a)
{
	D(bug("nfosmesa: glSamplePatternEXT"));
	fn.glSamplePatternEXT ( a);
}

void OSMesaDriver::nfglTextureColorMaskSGIS (GLboolean a, GLboolean b, GLboolean c, GLboolean d)
{
	D(bug("nfosmesa: glTextureColorMaskSGIS"));
	fn.glTextureColorMaskSGIS ( a,  b,  c,  d);
}

void OSMesaDriver::nfglIglooInterfaceSGIX (GLenum a, const GLvoid * b)
{
	D(bug("nfosmesa: glIglooInterfaceSGIX"));
	fn.glIglooInterfaceSGIX ( a,  b);
}

void OSMesaDriver::nfglDeleteFencesNV (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteFencesNV"));
	fn.glDeleteFencesNV ( a,  b);
}

void OSMesaDriver::nfglGenFencesNV (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenFencesNV"));
	fn.glGenFencesNV ( a,  b);
}

GLboolean OSMesaDriver::nfglIsFenceNV (GLuint a)
{
	D(bug("nfosmesa: glIsFenceNV"));
	return fn.glIsFenceNV ( a);
}

GLboolean OSMesaDriver::nfglTestFenceNV (GLuint a)
{
	D(bug("nfosmesa: glTestFenceNV"));
	return fn.glTestFenceNV ( a);
}

void OSMesaDriver::nfglGetFenceivNV (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetFenceivNV"));
	fn.glGetFenceivNV ( a,  b,  c);
}

void OSMesaDriver::nfglFinishFenceNV (GLuint a)
{
	D(bug("nfosmesa: glFinishFenceNV"));
	fn.glFinishFenceNV ( a);
}

void OSMesaDriver::nfglSetFenceNV (GLuint a, GLenum b)
{
	D(bug("nfosmesa: glSetFenceNV"));
	fn.glSetFenceNV ( a,  b);
}

void OSMesaDriver::nfglMapControlPointsNV (GLenum a, GLuint b, GLenum c, GLsizei d, GLsizei e, GLint f, GLint g, GLboolean h, const GLvoid * i)
{
	D(bug("nfosmesa: glMapControlPointsNV"));
	fn.glMapControlPointsNV ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglMapParameterivNV (GLenum a, GLenum b, const GLint * c)
{
	D(bug("nfosmesa: glMapParameterivNV"));
	fn.glMapParameterivNV ( a,  b,  c);
}

void OSMesaDriver::nfglMapParameterfvNV (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glMapParameterfvNV"));
	fn.glMapParameterfvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetMapControlPointsNV (GLenum a, GLuint b, GLenum c, GLsizei d, GLsizei e, GLboolean f, GLvoid * g)
{
	D(bug("nfosmesa: glGetMapControlPointsNV"));
	fn.glGetMapControlPointsNV ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglGetMapParameterivNV (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetMapParameterivNV"));
	fn.glGetMapParameterivNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetMapParameterfvNV (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetMapParameterfvNV"));
	fn.glGetMapParameterfvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetMapAttribParameterivNV (GLenum a, GLuint b, GLenum c, GLint * d)
{
	D(bug("nfosmesa: glGetMapAttribParameterivNV"));
	fn.glGetMapAttribParameterivNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetMapAttribParameterfvNV (GLenum a, GLuint b, GLenum c, GLfloat * d)
{
	D(bug("nfosmesa: glGetMapAttribParameterfvNV"));
	fn.glGetMapAttribParameterfvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglEvalMapsNV (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glEvalMapsNV"));
	fn.glEvalMapsNV ( a,  b);
}

void OSMesaDriver::nfglCombinerStageParameterfvNV (GLenum a, GLenum b, const GLfloat * c)
{
	D(bug("nfosmesa: glCombinerStageParameterfvNV"));
	fn.glCombinerStageParameterfvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetCombinerStageParameterfvNV (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetCombinerStageParameterfvNV"));
	fn.glGetCombinerStageParameterfvNV ( a,  b,  c);
}

GLboolean OSMesaDriver::nfglAreProgramsResidentNV (GLsizei a, const GLuint * b, GLboolean * c)
{
	D(bug("nfosmesa: glAreProgramsResidentNV"));
	return fn.glAreProgramsResidentNV ( a,  b,  c);
}

void OSMesaDriver::nfglBindProgramNV (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glBindProgramNV"));
	fn.glBindProgramNV ( a,  b);
}

void OSMesaDriver::nfglDeleteProgramsNV (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteProgramsNV"));
	fn.glDeleteProgramsNV ( a,  b);
}

void OSMesaDriver::nfglExecuteProgramNV (GLenum a, GLuint b, const GLfloat * c)
{
	D(bug("nfosmesa: glExecuteProgramNV"));
	fn.glExecuteProgramNV ( a,  b,  c);
}

void OSMesaDriver::nfglGenProgramsNV (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenProgramsNV"));
	fn.glGenProgramsNV ( a,  b);
}

void OSMesaDriver::nfglGetProgramParameterdvNV (GLenum a, GLuint b, GLenum c, GLdouble * d)
{
	D(bug("nfosmesa: glGetProgramParameterdvNV"));
	fn.glGetProgramParameterdvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetProgramParameterfvNV (GLenum a, GLuint b, GLenum c, GLfloat * d)
{
	D(bug("nfosmesa: glGetProgramParameterfvNV"));
	fn.glGetProgramParameterfvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetProgramivNV (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetProgramivNV"));
	fn.glGetProgramivNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetProgramStringNV (GLuint a, GLenum b, GLubyte * c)
{
	D(bug("nfosmesa: glGetProgramStringNV"));
	fn.glGetProgramStringNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetTrackMatrixivNV (GLenum a, GLuint b, GLenum c, GLint * d)
{
	D(bug("nfosmesa: glGetTrackMatrixivNV"));
	fn.glGetTrackMatrixivNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetVertexAttribdvNV (GLuint a, GLenum b, GLdouble * c)
{
	D(bug("nfosmesa: glGetVertexAttribdvNV"));
	fn.glGetVertexAttribdvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribfvNV (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetVertexAttribfvNV"));
	fn.glGetVertexAttribfvNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribivNV (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetVertexAttribivNV"));
	fn.glGetVertexAttribivNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribPointervNV (GLuint a, GLenum b, GLvoid* * c)
{
	D(bug("nfosmesa: glGetVertexAttribPointervNV"));
	fn.glGetVertexAttribPointervNV ( a,  b,  c);
}

GLboolean OSMesaDriver::nfglIsProgramNV (GLuint a)
{
	D(bug("nfosmesa: glIsProgramNV"));
	return fn.glIsProgramNV ( a);
}

void OSMesaDriver::nfglLoadProgramNV (GLenum a, GLuint b, GLsizei c, const GLubyte * d)
{
	D(bug("nfosmesa: glLoadProgramNV"));
	fn.glLoadProgramNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglProgramParameter4dNV (GLenum a, GLuint b, GLdouble c, GLdouble d, GLdouble e, GLdouble f)
{
	D(bug("nfosmesa: glProgramParameter4dNV"));
	fn.glProgramParameter4dNV ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramParameter4dvNV (GLenum a, GLuint b, const GLdouble * c)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glProgramParameter4dvNV"));
	Atari2HostDoublePtr(4, (Uint32 *)c, tmp);
	fn.glProgramParameter4dvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglProgramParameter4fNV (GLenum a, GLuint b, GLfloat c, GLfloat d, GLfloat e, GLfloat f)
{
	D(bug("nfosmesa: glProgramParameter4fNV"));
	fn.glProgramParameter4fNV ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglProgramParameter4fvNV (GLenum a, GLuint b, const GLfloat * c)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glProgramParameter4fvNV"));
	Atari2HostFloatPtr(4, (Uint32 *)c, tmp);
	fn.glProgramParameter4fvNV ( a,  b,  tmp);
}

void OSMesaDriver::nfglProgramParameters4dvNV (GLenum a, GLuint b, GLuint c, const GLdouble * d)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glProgramParameters4dvNV"));
	Atari2HostDoublePtr(4, (Uint32 *)d, tmp);
	fn.glProgramParameters4dvNV ( a,  b,  c, tmp);
}

void OSMesaDriver::nfglProgramParameters4fvNV (GLenum a, GLuint b, GLuint c, const GLfloat * d)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glProgramParameters4fvNV"));
	Atari2HostFloatPtr(4, (Uint32 *)d, tmp);
	fn.glProgramParameters4fvNV ( a,  b,  c, tmp);
}

void OSMesaDriver::nfglRequestResidentProgramsNV (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glRequestResidentProgramsNV"));
	fn.glRequestResidentProgramsNV ( a,  b);
}

void OSMesaDriver::nfglTrackMatrixNV (GLenum a, GLuint b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glTrackMatrixNV"));
	fn.glTrackMatrixNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttribPointerNV (GLuint a, GLint b, GLenum c, GLsizei d, const GLvoid * e)
{
	D(bug("nfosmesa: glVertexAttribPointerNV"));
	fn.glVertexAttribPointerNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib1dNV (GLuint a, GLdouble b)
{
	D(bug("nfosmesa: glVertexAttrib1dNV"));
	fn.glVertexAttrib1dNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1dvNV (GLuint a, const GLdouble * b)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glVertexAttrib1dvNV"));
	Atari2HostDoublePtr(1, (Uint32 *)b, tmp);
	fn.glVertexAttrib1dvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib1fNV (GLuint a, GLfloat b)
{
	D(bug("nfosmesa: glVertexAttrib1fNV"));
	fn.glVertexAttrib1fNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1fvNV (GLuint a, const GLfloat * b)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glVertexAttrib1fvNV"));
	Atari2HostFloatPtr(1, (Uint32 *)b, tmp);
	fn.glVertexAttrib1fvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib1sNV (GLuint a, GLshort b)
{
	D(bug("nfosmesa: glVertexAttrib1sNV"));
	fn.glVertexAttrib1sNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1svNV (GLuint a, const GLshort * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexAttrib1svNV"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glVertexAttrib1svNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib2dNV (GLuint a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glVertexAttrib2dNV"));
	fn.glVertexAttrib2dNV ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2dvNV (GLuint a, const GLdouble * b)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glVertexAttrib2dvNV"));
	Atari2HostDoublePtr(2, (Uint32 *)b, tmp);
	fn.glVertexAttrib2dvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib2fNV (GLuint a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glVertexAttrib2fNV"));
	fn.glVertexAttrib2fNV ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2fvNV (GLuint a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glVertexAttrib2fvNV"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glVertexAttrib2fvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib2sNV (GLuint a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glVertexAttrib2sNV"));
	fn.glVertexAttrib2sNV ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2svNV (GLuint a, const GLshort * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexAttrib2svNV"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glVertexAttrib2svNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3dNV (GLuint a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glVertexAttrib3dNV"));
	fn.glVertexAttrib3dNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3dvNV (GLuint a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glVertexAttrib3dvNV"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glVertexAttrib3dvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3fNV (GLuint a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glVertexAttrib3fNV"));
	fn.glVertexAttrib3fNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3fvNV (GLuint a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glVertexAttrib3fvNV"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glVertexAttrib3fvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib3sNV (GLuint a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glVertexAttrib3sNV"));
	fn.glVertexAttrib3sNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3svNV (GLuint a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexAttrib3svNV"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glVertexAttrib3svNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4dNV (GLuint a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{
	D(bug("nfosmesa: glVertexAttrib4dNV"));
	fn.glVertexAttrib4dNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4dvNV (GLuint a, const GLdouble * b)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glVertexAttrib4dvNV"));
	Atari2HostDoublePtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4dvNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib4fNV (GLuint a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glVertexAttrib4fNV"));
	fn.glVertexAttrib4fNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4fvNV (GLuint a, const GLfloat * b)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glVertexAttrib4fvNV"));
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp);
	fn.glVertexAttrib4fvNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4sNV (GLuint a, GLshort b, GLshort c, GLshort d, GLshort e)
{
	D(bug("nfosmesa: glVertexAttrib4sNV"));
	fn.glVertexAttrib4sNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4svNV (GLuint a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4svNV"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4svNV ( a, tmp);
}

void OSMesaDriver::nfglVertexAttrib4ubNV (GLuint a, GLubyte b, GLubyte c, GLubyte d, GLubyte e)
{
	D(bug("nfosmesa: glVertexAttrib4ubNV"));
	fn.glVertexAttrib4ubNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4ubvNV (GLuint a, const GLubyte * b)
{
	D(bug("nfosmesa: glVertexAttrib4ubvNV"));
	fn.glVertexAttrib4ubvNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttribs1dvNV (GLuint a, GLsizei b, const GLdouble * c)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glVertexAttribs1dvNV"));
	Atari2HostDoublePtr(1, (Uint32 *)c, tmp);
	fn.glVertexAttribs1dvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs1fvNV (GLuint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glVertexAttribs1fvNV"));
	Atari2HostFloatPtr(1, (Uint32 *)c, tmp);
	fn.glVertexAttribs1fvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs1svNV (GLuint a, GLsizei b, const GLshort * c)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexAttribs1svNV"));
	Atari2HostShortPtr(1, (Uint16 *)c, tmp);
	fn.glVertexAttribs1svNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs2dvNV (GLuint a, GLsizei b, const GLdouble * c)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glVertexAttribs2dvNV"));
	Atari2HostDoublePtr(2, (Uint32 *)c, tmp);
	fn.glVertexAttribs2dvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs2fvNV (GLuint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glVertexAttribs2fvNV"));
	Atari2HostFloatPtr(2, (Uint32 *)c, tmp);
	fn.glVertexAttribs2fvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs2svNV (GLuint a, GLsizei b, const GLshort * c)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexAttribs2svNV"));
	Atari2HostShortPtr(2, (Uint16 *)c, tmp);
	fn.glVertexAttribs2svNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs3dvNV (GLuint a, GLsizei b, const GLdouble * c)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glVertexAttribs3dvNV"));
	Atari2HostDoublePtr(3, (Uint32 *)c, tmp);
	fn.glVertexAttribs3dvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs3fvNV (GLuint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glVertexAttribs3fvNV"));
	Atari2HostFloatPtr(3, (Uint32 *)c, tmp);
	fn.glVertexAttribs3fvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs3svNV (GLuint a, GLsizei b, const GLshort * c)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexAttribs3svNV"));
	Atari2HostShortPtr(3, (Uint16 *)c, tmp);
	fn.glVertexAttribs3svNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs4dvNV (GLuint a, GLsizei b, const GLdouble * c)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glVertexAttribs4dvNV"));
	Atari2HostDoublePtr(4, (Uint32 *)c, tmp);
	fn.glVertexAttribs4dvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs4fvNV (GLuint a, GLsizei b, const GLfloat * c)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glVertexAttribs4fvNV"));
	Atari2HostFloatPtr(4, (Uint32 *)c, tmp);
	fn.glVertexAttribs4fvNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs4svNV (GLuint a, GLsizei b, const GLshort * c)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttribs4svNV"));
	Atari2HostShortPtr(4, (Uint16 *)c, tmp);
	fn.glVertexAttribs4svNV ( a,  b, tmp);
}

void OSMesaDriver::nfglVertexAttribs4ubvNV (GLuint a, GLsizei b, const GLubyte * c)
{
	D(bug("nfosmesa: glVertexAttribs4ubvNV"));
	fn.glVertexAttribs4ubvNV ( a,  b,  c);
}

void OSMesaDriver::nfglTexBumpParameterivATI (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glTexBumpParameterivATI"));
	fn.glTexBumpParameterivATI ( a,  b);
}

void OSMesaDriver::nfglTexBumpParameterfvATI (GLenum a, const GLfloat * b)
{
	D(bug("nfosmesa: glTexBumpParameterfvATI"));
	fn.glTexBumpParameterfvATI ( a,  b);
}

void OSMesaDriver::nfglGetTexBumpParameterivATI (GLenum a, GLint * b)
{
	D(bug("nfosmesa: glGetTexBumpParameterivATI"));
	fn.glGetTexBumpParameterivATI ( a,  b);
}

void OSMesaDriver::nfglGetTexBumpParameterfvATI (GLenum a, GLfloat * b)
{
	D(bug("nfosmesa: glGetTexBumpParameterfvATI"));
	fn.glGetTexBumpParameterfvATI ( a,  b);
}

GLuint OSMesaDriver::nfglGenFragmentShadersATI (GLuint a)
{
	D(bug("nfosmesa: glGenFragmentShadersATI"));
	return fn.glGenFragmentShadersATI ( a);
}

void OSMesaDriver::nfglBindFragmentShaderATI (GLuint a)
{
	D(bug("nfosmesa: glBindFragmentShaderATI"));
	fn.glBindFragmentShaderATI ( a);
}

void OSMesaDriver::nfglDeleteFragmentShaderATI (GLuint a)
{
	D(bug("nfosmesa: glDeleteFragmentShaderATI"));
	fn.glDeleteFragmentShaderATI ( a);
}

void OSMesaDriver::nfglBeginFragmentShaderATI (void )
{
	D(bug("nfosmesa: glBeginFragmentShaderATI"));
	fn.glBeginFragmentShaderATI ();
}

void OSMesaDriver::nfglEndFragmentShaderATI (void )
{
	D(bug("nfosmesa: glEndFragmentShaderATI"));
	fn.glEndFragmentShaderATI ();
}

void OSMesaDriver::nfglPassTexCoordATI (GLuint a, GLuint b, GLenum c)
{
	D(bug("nfosmesa: glPassTexCoordATI"));
	fn.glPassTexCoordATI ( a,  b,  c);
}

void OSMesaDriver::nfglSampleMapATI (GLuint a, GLuint b, GLenum c)
{
	D(bug("nfosmesa: glSampleMapATI"));
	fn.glSampleMapATI ( a,  b,  c);
}

void OSMesaDriver::nfglColorFragmentOp1ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f, GLuint g)
{
	D(bug("nfosmesa: glColorFragmentOp1ATI"));
	fn.glColorFragmentOp1ATI ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglColorFragmentOp2ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f, GLuint g, GLuint h, GLuint i, GLuint j)
{
	D(bug("nfosmesa: glColorFragmentOp2ATI"));
	fn.glColorFragmentOp2ATI ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j);
}

void OSMesaDriver::nfglColorFragmentOp3ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f, GLuint g, GLuint h, GLuint i, GLuint j, GLuint k, GLuint l, GLuint m)
{
	D(bug("nfosmesa: glColorFragmentOp3ATI"));
	fn.glColorFragmentOp3ATI ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l,  m);
}

void OSMesaDriver::nfglAlphaFragmentOp1ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f)
{
	D(bug("nfosmesa: glAlphaFragmentOp1ATI"));
	fn.glAlphaFragmentOp1ATI ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglAlphaFragmentOp2ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f, GLuint g, GLuint h, GLuint i)
{
	D(bug("nfosmesa: glAlphaFragmentOp2ATI"));
	fn.glAlphaFragmentOp2ATI ( a,  b,  c,  d,  e,  f,  g,  h,  i);
}

void OSMesaDriver::nfglAlphaFragmentOp3ATI (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e, GLuint f, GLuint g, GLuint h, GLuint i, GLuint j, GLuint k, GLuint l)
{
	D(bug("nfosmesa: glAlphaFragmentOp3ATI"));
	fn.glAlphaFragmentOp3ATI ( a,  b,  c,  d,  e,  f,  g,  h,  i,  j,  k,  l);
}

void OSMesaDriver::nfglSetFragmentShaderConstantATI (GLuint a, const GLfloat * b)
{
	D(bug("nfosmesa: glSetFragmentShaderConstantATI"));
	fn.glSetFragmentShaderConstantATI ( a,  b);
}

void OSMesaDriver::nfglPNTrianglesiATI (GLenum a, GLint b)
{
	D(bug("nfosmesa: glPNTrianglesiATI"));
	fn.glPNTrianglesiATI ( a,  b);
}

void OSMesaDriver::nfglPNTrianglesfATI (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glPNTrianglesfATI"));
	fn.glPNTrianglesfATI ( a,  b);
}

GLuint OSMesaDriver::nfglNewObjectBufferATI (GLsizei a, const GLvoid * b, GLenum c)
{
	D(bug("nfosmesa: glNewObjectBufferATI"));
	return fn.glNewObjectBufferATI ( a,  b,  c);
}

GLboolean OSMesaDriver::nfglIsObjectBufferATI (GLuint a)
{
	D(bug("nfosmesa: glIsObjectBufferATI"));
	return fn.glIsObjectBufferATI ( a);
}

void OSMesaDriver::nfglUpdateObjectBufferATI (GLuint a, GLuint b, GLsizei c, const GLvoid * d, GLenum e)
{
	D(bug("nfosmesa: glUpdateObjectBufferATI"));
	fn.glUpdateObjectBufferATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetObjectBufferfvATI (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetObjectBufferfvATI"));
	fn.glGetObjectBufferfvATI ( a,  b,  c);
}

void OSMesaDriver::nfglGetObjectBufferivATI (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetObjectBufferivATI"));
	fn.glGetObjectBufferivATI ( a,  b,  c);
}

void OSMesaDriver::nfglFreeObjectBufferATI (GLuint a)
{
	D(bug("nfosmesa: glFreeObjectBufferATI"));
	fn.glFreeObjectBufferATI ( a);
}

void OSMesaDriver::nfglArrayObjectATI (GLenum a, GLint b, GLenum c, GLsizei d, GLuint e, GLuint f)
{
	D(bug("nfosmesa: glArrayObjectATI"));
	fn.glArrayObjectATI ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglGetArrayObjectfvATI (GLenum a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetArrayObjectfvATI"));
	fn.glGetArrayObjectfvATI ( a,  b,  c);
}

void OSMesaDriver::nfglGetArrayObjectivATI (GLenum a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetArrayObjectivATI"));
	fn.glGetArrayObjectivATI ( a,  b,  c);
}

void OSMesaDriver::nfglVariantArrayObjectATI (GLuint a, GLenum b, GLsizei c, GLuint d, GLuint e)
{
	D(bug("nfosmesa: glVariantArrayObjectATI"));
	fn.glVariantArrayObjectATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglGetVariantArrayObjectfvATI (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetVariantArrayObjectfvATI"));
	fn.glGetVariantArrayObjectfvATI ( a,  b,  c);
}

void OSMesaDriver::nfglGetVariantArrayObjectivATI (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetVariantArrayObjectivATI"));
	fn.glGetVariantArrayObjectivATI ( a,  b,  c);
}

void OSMesaDriver::nfglBeginVertexShaderEXT (void )
{
	D(bug("nfosmesa: glBeginVertexShaderEXT"));
	fn.glBeginVertexShaderEXT ();
}

void OSMesaDriver::nfglEndVertexShaderEXT (void )
{
	D(bug("nfosmesa: glEndVertexShaderEXT"));
	fn.glEndVertexShaderEXT ();
}

void OSMesaDriver::nfglBindVertexShaderEXT (GLuint a)
{
	D(bug("nfosmesa: glBindVertexShaderEXT"));
	fn.glBindVertexShaderEXT ( a);
}

GLuint OSMesaDriver::nfglGenVertexShadersEXT (GLuint a)
{
	D(bug("nfosmesa: glGenVertexShadersEXT"));
	return fn.glGenVertexShadersEXT ( a);
}

void OSMesaDriver::nfglDeleteVertexShaderEXT (GLuint a)
{
	D(bug("nfosmesa: glDeleteVertexShaderEXT"));
	fn.glDeleteVertexShaderEXT ( a);
}

void OSMesaDriver::nfglShaderOp1EXT (GLenum a, GLuint b, GLuint c)
{
	D(bug("nfosmesa: glShaderOp1EXT"));
	fn.glShaderOp1EXT ( a,  b,  c);
}

void OSMesaDriver::nfglShaderOp2EXT (GLenum a, GLuint b, GLuint c, GLuint d)
{
	D(bug("nfosmesa: glShaderOp2EXT"));
	fn.glShaderOp2EXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglShaderOp3EXT (GLenum a, GLuint b, GLuint c, GLuint d, GLuint e)
{
	D(bug("nfosmesa: glShaderOp3EXT"));
	fn.glShaderOp3EXT ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglSwizzleEXT (GLuint a, GLuint b, GLenum c, GLenum d, GLenum e, GLenum f)
{
	D(bug("nfosmesa: glSwizzleEXT"));
	fn.glSwizzleEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglWriteMaskEXT (GLuint a, GLuint b, GLenum c, GLenum d, GLenum e, GLenum f)
{
	D(bug("nfosmesa: glWriteMaskEXT"));
	fn.glWriteMaskEXT ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglInsertComponentEXT (GLuint a, GLuint b, GLuint c)
{
	D(bug("nfosmesa: glInsertComponentEXT"));
	fn.glInsertComponentEXT ( a,  b,  c);
}

void OSMesaDriver::nfglExtractComponentEXT (GLuint a, GLuint b, GLuint c)
{
	D(bug("nfosmesa: glExtractComponentEXT"));
	fn.glExtractComponentEXT ( a,  b,  c);
}

GLuint OSMesaDriver::nfglGenSymbolsEXT (GLenum a, GLenum b, GLenum c, GLuint d)
{
	D(bug("nfosmesa: glGenSymbolsEXT"));
	return fn.glGenSymbolsEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglSetInvariantEXT (GLuint a, GLenum b, const GLvoid * c)
{
	D(bug("nfosmesa: glSetInvariantEXT"));
	fn.glSetInvariantEXT ( a,  b,  c);
}

void OSMesaDriver::nfglSetLocalConstantEXT (GLuint a, GLenum b, const GLvoid * c)
{
	D(bug("nfosmesa: glSetLocalConstantEXT"));
	fn.glSetLocalConstantEXT ( a,  b,  c);
}

void OSMesaDriver::nfglVariantbvEXT (GLuint a, const GLbyte * b)
{
	D(bug("nfosmesa: glVariantbvEXT"));
	fn.glVariantbvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantsvEXT (GLuint a, const GLshort * b)
{
	D(bug("nfosmesa: glVariantsvEXT"));
	fn.glVariantsvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantivEXT (GLuint a, const GLint * b)
{
	D(bug("nfosmesa: glVariantivEXT"));
	fn.glVariantivEXT ( a,  b);
}

void OSMesaDriver::nfglVariantfvEXT (GLuint a, const GLfloat * b)
{
	D(bug("nfosmesa: glVariantfvEXT"));
	fn.glVariantfvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantdvEXT (GLuint a, const GLdouble * b)
{
	D(bug("nfosmesa: glVariantdvEXT"));
	fn.glVariantdvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantubvEXT (GLuint a, const GLubyte * b)
{
	D(bug("nfosmesa: glVariantubvEXT"));
	fn.glVariantubvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantusvEXT (GLuint a, const GLushort * b)
{
	D(bug("nfosmesa: glVariantusvEXT"));
	fn.glVariantusvEXT ( a,  b);
}

void OSMesaDriver::nfglVariantuivEXT (GLuint a, const GLuint * b)
{
	D(bug("nfosmesa: glVariantuivEXT"));
	fn.glVariantuivEXT ( a,  b);
}

void OSMesaDriver::nfglVariantPointerEXT (GLuint a, GLenum b, GLuint c, const GLvoid * d)
{
	D(bug("nfosmesa: glVariantPointerEXT"));
	fn.glVariantPointerEXT ( a,  b,  c,  d);
}

void OSMesaDriver::nfglEnableVariantClientStateEXT (GLuint a)
{
	D(bug("nfosmesa: glEnableVariantClientStateEXT"));
	fn.glEnableVariantClientStateEXT ( a);
}

void OSMesaDriver::nfglDisableVariantClientStateEXT (GLuint a)
{
	D(bug("nfosmesa: glDisableVariantClientStateEXT"));
	fn.glDisableVariantClientStateEXT ( a);
}

GLuint OSMesaDriver::nfglBindLightParameterEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glBindLightParameterEXT"));
	return fn.glBindLightParameterEXT ( a,  b);
}

GLuint OSMesaDriver::nfglBindMaterialParameterEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glBindMaterialParameterEXT"));
	return fn.glBindMaterialParameterEXT ( a,  b);
}

GLuint OSMesaDriver::nfglBindTexGenParameterEXT (GLenum a, GLenum b, GLenum c)
{
	D(bug("nfosmesa: glBindTexGenParameterEXT"));
	return fn.glBindTexGenParameterEXT ( a,  b,  c);
}

GLuint OSMesaDriver::nfglBindTextureUnitParameterEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glBindTextureUnitParameterEXT"));
	return fn.glBindTextureUnitParameterEXT ( a,  b);
}

GLuint OSMesaDriver::nfglBindParameterEXT (GLenum a)
{
	D(bug("nfosmesa: glBindParameterEXT"));
	return fn.glBindParameterEXT ( a);
}

GLboolean OSMesaDriver::nfglIsVariantEnabledEXT (GLuint a, GLenum b)
{
	D(bug("nfosmesa: glIsVariantEnabledEXT"));
	return fn.glIsVariantEnabledEXT ( a,  b);
}

void OSMesaDriver::nfglGetVariantBooleanvEXT (GLuint a, GLenum b, GLboolean * c)
{
	D(bug("nfosmesa: glGetVariantBooleanvEXT"));
	fn.glGetVariantBooleanvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetVariantIntegervEXT (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetVariantIntegervEXT"));
	fn.glGetVariantIntegervEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetVariantFloatvEXT (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetVariantFloatvEXT"));
	fn.glGetVariantFloatvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetVariantPointervEXT (GLuint a, GLenum b, GLvoid* * c)
{
	D(bug("nfosmesa: glGetVariantPointervEXT"));
	fn.glGetVariantPointervEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetInvariantBooleanvEXT (GLuint a, GLenum b, GLboolean * c)
{
	D(bug("nfosmesa: glGetInvariantBooleanvEXT"));
	fn.glGetInvariantBooleanvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetInvariantIntegervEXT (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetInvariantIntegervEXT"));
	fn.glGetInvariantIntegervEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetInvariantFloatvEXT (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetInvariantFloatvEXT"));
	fn.glGetInvariantFloatvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetLocalConstantBooleanvEXT (GLuint a, GLenum b, GLboolean * c)
{
	D(bug("nfosmesa: glGetLocalConstantBooleanvEXT"));
	fn.glGetLocalConstantBooleanvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetLocalConstantIntegervEXT (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetLocalConstantIntegervEXT"));
	fn.glGetLocalConstantIntegervEXT ( a,  b,  c);
}

void OSMesaDriver::nfglGetLocalConstantFloatvEXT (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetLocalConstantFloatvEXT"));
	fn.glGetLocalConstantFloatvEXT ( a,  b,  c);
}

void OSMesaDriver::nfglVertexStream1sATI (GLenum a, GLshort b)
{
	D(bug("nfosmesa: glVertexStream1sATI"));
	fn.glVertexStream1sATI ( a,  b);
}

void OSMesaDriver::nfglVertexStream1svATI (GLenum a, const GLshort * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexStream1svATI"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glVertexStream1svATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream1iATI (GLenum a, GLint b)
{
	D(bug("nfosmesa: glVertexStream1iATI"));
	fn.glVertexStream1iATI ( a,  b);
}

void OSMesaDriver::nfglVertexStream1ivATI (GLenum a, const GLint * b)
{
	GLint tmp[1];

	D(bug("nfosmesa: glVertexStream1ivATI"));
	Atari2HostIntPtr(1, (Uint32 *)b, tmp);
	fn.glVertexStream1ivATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream1fATI (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glVertexStream1fATI"));
	fn.glVertexStream1fATI ( a,  b);
}

void OSMesaDriver::nfglVertexStream1fvATI (GLenum a, const GLfloat * b)
{
	GLfloat tmp[1];

	D(bug("nfosmesa: glVertexStream1fvATI"));
	Atari2HostFloatPtr(1, (Uint32 *)b, tmp);
	fn.glVertexStream1fvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream1dATI (GLenum a, GLdouble b)
{
	D(bug("nfosmesa: glVertexStream1dATI"));
	fn.glVertexStream1dATI ( a,  b);
}

void OSMesaDriver::nfglVertexStream1dvATI (GLenum a, const GLdouble * b)
{
	GLdouble tmp[1];

	D(bug("nfosmesa: glVertexStream1dvATI"));
	Atari2HostDoublePtr(1, (Uint32 *)b, tmp);
	fn.glVertexStream1dvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream2sATI (GLenum a, GLshort b, GLshort c)
{
	D(bug("nfosmesa: glVertexStream2sATI"));
	fn.glVertexStream2sATI ( a,  b,  c);
}

void OSMesaDriver::nfglVertexStream2svATI (GLenum a, const GLshort * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexStream2svATI"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glVertexStream2svATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream2iATI (GLenum a, GLint b, GLint c)
{
	D(bug("nfosmesa: glVertexStream2iATI"));
	fn.glVertexStream2iATI ( a,  b,  c);
}

void OSMesaDriver::nfglVertexStream2ivATI (GLenum a, const GLint * b)
{
	GLint tmp[2];

	D(bug("nfosmesa: glVertexStream2ivATI"));
	Atari2HostIntPtr(2, (Uint32 *)b, tmp);
	fn.glVertexStream2ivATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream2fATI (GLenum a, GLfloat b, GLfloat c)
{
	D(bug("nfosmesa: glVertexStream2fATI"));
	fn.glVertexStream2fATI ( a,  b,  c);
}

void OSMesaDriver::nfglVertexStream2fvATI (GLenum a, const GLfloat * b)
{
	GLfloat tmp[2];

	D(bug("nfosmesa: glVertexStream2fvATI"));
	Atari2HostFloatPtr(2, (Uint32 *)b, tmp);
	fn.glVertexStream2fvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream2dATI (GLenum a, GLdouble b, GLdouble c)
{
	D(bug("nfosmesa: glVertexStream2dATI"));
	fn.glVertexStream2dATI ( a,  b,  c);
}

void OSMesaDriver::nfglVertexStream2dvATI (GLenum a, const GLdouble * b)
{
	GLdouble tmp[2];

	D(bug("nfosmesa: glVertexStream2dvATI"));
	Atari2HostDoublePtr(2, (Uint32 *)b, tmp);
	fn.glVertexStream2dvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream3sATI (GLenum a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glVertexStream3sATI"));
	fn.glVertexStream3sATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexStream3svATI (GLenum a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexStream3svATI"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glVertexStream3svATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream3iATI (GLenum a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glVertexStream3iATI"));
	fn.glVertexStream3iATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexStream3ivATI (GLenum a, const GLint * b)
{
	GLint tmp[3];

	D(bug("nfosmesa: glVertexStream3ivATI"));
	Atari2HostIntPtr(3, (Uint32 *)b, tmp);
	fn.glVertexStream3ivATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream3fATI (GLenum a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glVertexStream3fATI"));
	fn.glVertexStream3fATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexStream3fvATI (GLenum a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glVertexStream3fvATI"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glVertexStream3fvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream3dATI (GLenum a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glVertexStream3dATI"));
	fn.glVertexStream3dATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexStream3dvATI (GLenum a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glVertexStream3dvATI"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glVertexStream3dvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream4sATI (GLenum a, GLshort b, GLshort c, GLshort d, GLshort e)
{
	D(bug("nfosmesa: glVertexStream4sATI"));
	fn.glVertexStream4sATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexStream4svATI (GLenum a, const GLshort * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexStream4svATI"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexStream4svATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream4iATI (GLenum a, GLint b, GLint c, GLint d, GLint e)
{
	D(bug("nfosmesa: glVertexStream4iATI"));
	fn.glVertexStream4iATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexStream4ivATI (GLenum a, const GLint * b)
{
	GLint tmp[4];

	D(bug("nfosmesa: glVertexStream4ivATI"));
	Atari2HostIntPtr(4, (Uint32 *)b, tmp);
	fn.glVertexStream4ivATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream4fATI (GLenum a, GLfloat b, GLfloat c, GLfloat d, GLfloat e)
{
	D(bug("nfosmesa: glVertexStream4fATI"));
	fn.glVertexStream4fATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexStream4fvATI (GLenum a, const GLfloat * b)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glVertexStream4fvATI"));
	Atari2HostFloatPtr(4, (Uint32 *)b, tmp);
	fn.glVertexStream4fvATI ( a, tmp);
}

void OSMesaDriver::nfglVertexStream4dATI (GLenum a, GLdouble b, GLdouble c, GLdouble d, GLdouble e)
{
	D(bug("nfosmesa: glVertexStream4dATI"));
	fn.glVertexStream4dATI ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexStream4dvATI (GLenum a, const GLdouble * b)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glVertexStream4dvATI"));
	Atari2HostDoublePtr(4, (Uint32 *)b, tmp);
	fn.glVertexStream4dvATI ( a, tmp);
}

void OSMesaDriver::nfglNormalStream3bATI (GLenum a, GLbyte b, GLbyte c, GLbyte d)
{
	D(bug("nfosmesa: glNormalStream3bATI"));
	fn.glNormalStream3bATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalStream3bvATI (GLenum a, const GLbyte * b)
{
	D(bug("nfosmesa: glNormalStream3bvATI"));
	fn.glNormalStream3bvATI ( a,  b);
}

void OSMesaDriver::nfglNormalStream3sATI (GLenum a, GLshort b, GLshort c, GLshort d)
{
	D(bug("nfosmesa: glNormalStream3sATI"));
	fn.glNormalStream3sATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalStream3svATI (GLenum a, const GLshort * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glNormalStream3svATI"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glNormalStream3svATI ( a, tmp);
}

void OSMesaDriver::nfglNormalStream3iATI (GLenum a, GLint b, GLint c, GLint d)
{
	D(bug("nfosmesa: glNormalStream3iATI"));
	fn.glNormalStream3iATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalStream3ivATI (GLenum a, const GLint * b)
{
	GLint tmp[3];

	D(bug("nfosmesa: glNormalStream3ivATI"));
	Atari2HostIntPtr(3, (Uint32 *)b, tmp);
	fn.glNormalStream3ivATI ( a, tmp);
}

void OSMesaDriver::nfglNormalStream3fATI (GLenum a, GLfloat b, GLfloat c, GLfloat d)
{
	D(bug("nfosmesa: glNormalStream3fATI"));
	fn.glNormalStream3fATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalStream3fvATI (GLenum a, const GLfloat * b)
{
	GLfloat tmp[3];

	D(bug("nfosmesa: glNormalStream3fvATI"));
	Atari2HostFloatPtr(3, (Uint32 *)b, tmp);
	fn.glNormalStream3fvATI ( a, tmp);
}

void OSMesaDriver::nfglNormalStream3dATI (GLenum a, GLdouble b, GLdouble c, GLdouble d)
{
	D(bug("nfosmesa: glNormalStream3dATI"));
	fn.glNormalStream3dATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglNormalStream3dvATI (GLenum a, const GLdouble * b)
{
	GLdouble tmp[3];

	D(bug("nfosmesa: glNormalStream3dvATI"));
	Atari2HostDoublePtr(3, (Uint32 *)b, tmp);
	fn.glNormalStream3dvATI ( a, tmp);
}

void OSMesaDriver::nfglClientActiveVertexStreamATI (GLenum a)
{
	D(bug("nfosmesa: glClientActiveVertexStreamATI"));
	fn.glClientActiveVertexStreamATI ( a);
}

void OSMesaDriver::nfglVertexBlendEnviATI (GLenum a, GLint b)
{
	D(bug("nfosmesa: glVertexBlendEnviATI"));
	fn.glVertexBlendEnviATI ( a,  b);
}

void OSMesaDriver::nfglVertexBlendEnvfATI (GLenum a, GLfloat b)
{
	D(bug("nfosmesa: glVertexBlendEnvfATI"));
	fn.glVertexBlendEnvfATI ( a,  b);
}

void OSMesaDriver::nfglElementPointerATI (GLenum a, const GLvoid * b)
{
	D(bug("nfosmesa: glElementPointerATI"));
	fn.glElementPointerATI ( a,  b);
}

void OSMesaDriver::nfglDrawElementArrayATI (GLenum a, GLsizei b)
{
	D(bug("nfosmesa: glDrawElementArrayATI"));
	fn.glDrawElementArrayATI ( a,  b);
}

void OSMesaDriver::nfglDrawRangeElementArrayATI (GLenum a, GLuint b, GLuint c, GLsizei d)
{
	D(bug("nfosmesa: glDrawRangeElementArrayATI"));
	fn.glDrawRangeElementArrayATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglDrawMeshArraysSUN (GLenum a, GLint b, GLsizei c, GLsizei d)
{
	D(bug("nfosmesa: glDrawMeshArraysSUN"));
	fn.glDrawMeshArraysSUN ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGenOcclusionQueriesNV (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenOcclusionQueriesNV"));
	fn.glGenOcclusionQueriesNV ( a,  b);
}

void OSMesaDriver::nfglDeleteOcclusionQueriesNV (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteOcclusionQueriesNV"));
	fn.glDeleteOcclusionQueriesNV ( a,  b);
}

GLboolean OSMesaDriver::nfglIsOcclusionQueryNV (GLuint a)
{
	D(bug("nfosmesa: glIsOcclusionQueryNV"));
	return fn.glIsOcclusionQueryNV ( a);
}

void OSMesaDriver::nfglBeginOcclusionQueryNV (GLuint a)
{
	D(bug("nfosmesa: glBeginOcclusionQueryNV"));
	fn.glBeginOcclusionQueryNV ( a);
}

void OSMesaDriver::nfglEndOcclusionQueryNV (void )
{
	D(bug("nfosmesa: glEndOcclusionQueryNV"));
	fn.glEndOcclusionQueryNV ();
}

void OSMesaDriver::nfglGetOcclusionQueryivNV (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetOcclusionQueryivNV"));
	fn.glGetOcclusionQueryivNV ( a,  b,  c);
}

void OSMesaDriver::nfglGetOcclusionQueryuivNV (GLuint a, GLenum b, GLuint * c)
{
	D(bug("nfosmesa: glGetOcclusionQueryuivNV"));
	fn.glGetOcclusionQueryuivNV ( a,  b,  c);
}

void OSMesaDriver::nfglPointParameteriNV (GLenum a, GLint b)
{
	D(bug("nfosmesa: glPointParameteriNV"));
	fn.glPointParameteriNV ( a,  b);
}

void OSMesaDriver::nfglPointParameterivNV (GLenum a, const GLint * b)
{
	D(bug("nfosmesa: glPointParameterivNV"));
	fn.glPointParameterivNV ( a,  b);
}

void OSMesaDriver::nfglActiveStencilFaceEXT (GLenum a)
{
	D(bug("nfosmesa: glActiveStencilFaceEXT"));
	fn.glActiveStencilFaceEXT ( a);
}

void OSMesaDriver::nfglElementPointerAPPLE (GLenum a, const GLvoid * b)
{
	D(bug("nfosmesa: glElementPointerAPPLE"));
	fn.glElementPointerAPPLE ( a,  b);
}

void OSMesaDriver::nfglDrawElementArrayAPPLE (GLenum a, GLint b, GLsizei c)
{
	D(bug("nfosmesa: glDrawElementArrayAPPLE"));
	fn.glDrawElementArrayAPPLE ( a,  b,  c);
}

void OSMesaDriver::nfglDrawRangeElementArrayAPPLE (GLenum a, GLuint b, GLuint c, GLint d, GLsizei e)
{
	D(bug("nfosmesa: glDrawRangeElementArrayAPPLE"));
	fn.glDrawRangeElementArrayAPPLE ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiDrawElementArrayAPPLE (GLenum a, const GLint * b, const GLsizei * c, GLsizei d)
{
	D(bug("nfosmesa: glMultiDrawElementArrayAPPLE"));
	fn.glMultiDrawElementArrayAPPLE ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiDrawRangeElementArrayAPPLE (GLenum a, GLuint b, GLuint c, const GLint * d, const GLsizei * e, GLsizei f)
{
	D(bug("nfosmesa: glMultiDrawRangeElementArrayAPPLE"));
	fn.glMultiDrawRangeElementArrayAPPLE ( a,  b,  c,  d,  e,  f);
}

void OSMesaDriver::nfglGenFencesAPPLE (GLsizei a, GLuint * b)
{
	D(bug("nfosmesa: glGenFencesAPPLE"));
	fn.glGenFencesAPPLE ( a,  b);
}

void OSMesaDriver::nfglDeleteFencesAPPLE (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteFencesAPPLE"));
	fn.glDeleteFencesAPPLE ( a,  b);
}

void OSMesaDriver::nfglSetFenceAPPLE (GLuint a)
{
	D(bug("nfosmesa: glSetFenceAPPLE"));
	fn.glSetFenceAPPLE ( a);
}

GLboolean OSMesaDriver::nfglIsFenceAPPLE (GLuint a)
{
	D(bug("nfosmesa: glIsFenceAPPLE"));
	return fn.glIsFenceAPPLE ( a);
}

GLboolean OSMesaDriver::nfglTestFenceAPPLE (GLuint a)
{
	D(bug("nfosmesa: glTestFenceAPPLE"));
	return fn.glTestFenceAPPLE ( a);
}

void OSMesaDriver::nfglFinishFenceAPPLE (GLuint a)
{
	D(bug("nfosmesa: glFinishFenceAPPLE"));
	fn.glFinishFenceAPPLE ( a);
}

GLboolean OSMesaDriver::nfglTestObjectAPPLE (GLenum a, GLuint b)
{
	D(bug("nfosmesa: glTestObjectAPPLE"));
	return fn.glTestObjectAPPLE ( a,  b);
}

void OSMesaDriver::nfglFinishObjectAPPLE (GLenum a, GLint b)
{
	D(bug("nfosmesa: glFinishObjectAPPLE"));
	fn.glFinishObjectAPPLE ( a,  b);
}

void OSMesaDriver::nfglBindVertexArrayAPPLE (GLuint a)
{
	D(bug("nfosmesa: glBindVertexArrayAPPLE"));
	fn.glBindVertexArrayAPPLE ( a);
}

void OSMesaDriver::nfglDeleteVertexArraysAPPLE (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glDeleteVertexArraysAPPLE"));
	fn.glDeleteVertexArraysAPPLE ( a,  b);
}

void OSMesaDriver::nfglGenVertexArraysAPPLE (GLsizei a, const GLuint * b)
{
	D(bug("nfosmesa: glGenVertexArraysAPPLE"));
	fn.glGenVertexArraysAPPLE ( a,  b);
}

GLboolean OSMesaDriver::nfglIsVertexArrayAPPLE (GLuint a)
{
	D(bug("nfosmesa: glIsVertexArrayAPPLE"));
	return fn.glIsVertexArrayAPPLE ( a);
}

void OSMesaDriver::nfglVertexArrayRangeAPPLE (GLsizei a, GLvoid * b)
{
	D(bug("nfosmesa: glVertexArrayRangeAPPLE"));
	fn.glVertexArrayRangeAPPLE ( a,  b);
}

void OSMesaDriver::nfglFlushVertexArrayRangeAPPLE (GLsizei a, GLvoid * b)
{
	D(bug("nfosmesa: glFlushVertexArrayRangeAPPLE"));
	fn.glFlushVertexArrayRangeAPPLE ( a,  b);
}

void OSMesaDriver::nfglVertexArrayParameteriAPPLE (GLenum a, GLint b)
{
	D(bug("nfosmesa: glVertexArrayParameteriAPPLE"));
	fn.glVertexArrayParameteriAPPLE ( a,  b);
}

void OSMesaDriver::nfglDrawBuffersATI (GLsizei a, const GLenum * b)
{
	D(bug("nfosmesa: glDrawBuffersATI"));
	fn.glDrawBuffersATI ( a,  b);
}

void OSMesaDriver::nfglProgramNamedParameter4fNV (GLuint a, GLsizei b, const GLubyte * c, GLfloat d, GLfloat e, GLfloat f, GLfloat g)
{
	D(bug("nfosmesa: glProgramNamedParameter4fNV"));
	fn.glProgramNamedParameter4fNV ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglProgramNamedParameter4dNV (GLuint a, GLsizei b, const GLubyte * c, GLdouble d, GLdouble e, GLdouble f, GLdouble g)
{
	D(bug("nfosmesa: glProgramNamedParameter4dNV"));
	fn.glProgramNamedParameter4dNV ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglProgramNamedParameter4fvNV (GLuint a, GLsizei b, const GLubyte * c, const GLfloat * d)
{
	GLfloat tmp[4];

	D(bug("nfosmesa: glProgramNamedParameter4fvNV"));
	Atari2HostFloatPtr(4, (Uint32 *)d, tmp);
	fn.glProgramNamedParameter4fvNV ( a,  b,  c, tmp);
}

void OSMesaDriver::nfglProgramNamedParameter4dvNV (GLuint a, GLsizei b, const GLubyte * c, const GLdouble * d)
{
	GLdouble tmp[4];

	D(bug("nfosmesa: glProgramNamedParameter4dvNV"));
	Atari2HostDoublePtr(4, (Uint32 *)d, tmp);
	fn.glProgramNamedParameter4dvNV ( a,  b,  c, tmp);
}

void OSMesaDriver::nfglGetProgramNamedParameterfvNV (GLuint a, GLsizei b, const GLubyte * c, GLfloat * d)
{
	D(bug("nfosmesa: glGetProgramNamedParameterfvNV"));
	fn.glGetProgramNamedParameterfvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglGetProgramNamedParameterdvNV (GLuint a, GLsizei b, const GLubyte * c, GLdouble * d)
{
	D(bug("nfosmesa: glGetProgramNamedParameterdvNV"));
	fn.glGetProgramNamedParameterdvNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertex2hNV (GLhalfNV a, GLhalfNV b)
{
	D(bug("nfosmesa: glVertex2hNV"));
	fn.glVertex2hNV ( a,  b);
}

void OSMesaDriver::nfglVertex2hvNV (const GLhalfNV * a)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertex2hvNV"));
	Atari2HostShortPtr(2, (Uint16 *)a, tmp);
	fn.glVertex2hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertex3hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glVertex3hNV"));
	fn.glVertex3hNV ( a,  b,  c);
}

void OSMesaDriver::nfglVertex3hvNV (const GLhalfNV * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertex3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glVertex3hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertex4hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c, GLhalfNV d)
{
	D(bug("nfosmesa: glVertex4hNV"));
	fn.glVertex4hNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertex4hvNV (const GLhalfNV * a)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertex4hvNV"));
	Atari2HostShortPtr(4, (Uint16 *)a, tmp);
	fn.glVertex4hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglNormal3hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glNormal3hNV"));
	fn.glNormal3hNV ( a,  b,  c);
}

void OSMesaDriver::nfglNormal3hvNV (const GLhalfNV * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glNormal3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glNormal3hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglColor3hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glColor3hNV"));
	fn.glColor3hNV ( a,  b,  c);
}

void OSMesaDriver::nfglColor3hvNV (const GLhalfNV * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glColor3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glColor3hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglColor4hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c, GLhalfNV d)
{
	D(bug("nfosmesa: glColor4hNV"));
	fn.glColor4hNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglColor4hvNV (const GLhalfNV * a)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glColor4hvNV"));
	Atari2HostShortPtr(4, (Uint16 *)a, tmp);
	fn.glColor4hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglTexCoord1hNV (GLhalfNV a)
{
	D(bug("nfosmesa: glTexCoord1hNV"));
	fn.glTexCoord1hNV ( a);
}

void OSMesaDriver::nfglTexCoord1hvNV (const GLhalfNV * a)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glTexCoord1hvNV"));
	Atari2HostShortPtr(1, (Uint16 *)a, tmp);
	fn.glTexCoord1hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglTexCoord2hNV (GLhalfNV a, GLhalfNV b)
{
	D(bug("nfosmesa: glTexCoord2hNV"));
	fn.glTexCoord2hNV ( a,  b);
}

void OSMesaDriver::nfglTexCoord2hvNV (const GLhalfNV * a)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glTexCoord2hvNV"));
	Atari2HostShortPtr(2, (Uint16 *)a, tmp);
	fn.glTexCoord2hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglTexCoord3hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glTexCoord3hNV"));
	fn.glTexCoord3hNV ( a,  b,  c);
}

void OSMesaDriver::nfglTexCoord3hvNV (const GLhalfNV * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glTexCoord3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glTexCoord3hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglTexCoord4hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c, GLhalfNV d)
{
	D(bug("nfosmesa: glTexCoord4hNV"));
	fn.glTexCoord4hNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglTexCoord4hvNV (const GLhalfNV * a)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glTexCoord4hvNV"));
	Atari2HostShortPtr(4, (Uint16 *)a, tmp);
	fn.glTexCoord4hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglMultiTexCoord1hNV (GLenum a, GLhalfNV b)
{
	D(bug("nfosmesa: glMultiTexCoord1hNV"));
	fn.glMultiTexCoord1hNV ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord1hvNV (GLenum a, const GLhalfNV * b)
{
	D(bug("nfosmesa: glMultiTexCoord1hvNV"));
	fn.glMultiTexCoord1hvNV ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord2hNV (GLenum a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glMultiTexCoord2hNV"));
	fn.glMultiTexCoord2hNV ( a,  b,  c);
}

void OSMesaDriver::nfglMultiTexCoord2hvNV (GLenum a, const GLhalfNV * b)
{
	D(bug("nfosmesa: glMultiTexCoord2hvNV"));
	fn.glMultiTexCoord2hvNV ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord3hNV (GLenum a, GLhalfNV b, GLhalfNV c, GLhalfNV d)
{
	D(bug("nfosmesa: glMultiTexCoord3hNV"));
	fn.glMultiTexCoord3hNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglMultiTexCoord3hvNV (GLenum a, const GLhalfNV * b)
{
	D(bug("nfosmesa: glMultiTexCoord3hvNV"));
	fn.glMultiTexCoord3hvNV ( a,  b);
}

void OSMesaDriver::nfglMultiTexCoord4hNV (GLenum a, GLhalfNV b, GLhalfNV c, GLhalfNV d, GLhalfNV e)
{
	D(bug("nfosmesa: glMultiTexCoord4hNV"));
	fn.glMultiTexCoord4hNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglMultiTexCoord4hvNV (GLenum a, const GLhalfNV * b)
{
	D(bug("nfosmesa: glMultiTexCoord4hvNV"));
	fn.glMultiTexCoord4hvNV ( a,  b);
}

void OSMesaDriver::nfglFogCoordhNV (GLhalfNV a)
{
	D(bug("nfosmesa: glFogCoordhNV"));
	fn.glFogCoordhNV ( a);
}

void OSMesaDriver::nfglFogCoordhvNV (const GLhalfNV * a)
{
	D(bug("nfosmesa: glFogCoordhvNV"));
	fn.glFogCoordhvNV ( a);
}

void OSMesaDriver::nfglSecondaryColor3hNV (GLhalfNV a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glSecondaryColor3hNV"));
	fn.glSecondaryColor3hNV ( a,  b,  c);
}

void OSMesaDriver::nfglSecondaryColor3hvNV (const GLhalfNV * a)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glSecondaryColor3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)a, tmp);
	fn.glSecondaryColor3hvNV ( (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexWeighthNV (GLhalfNV a)
{
	D(bug("nfosmesa: glVertexWeighthNV"));
	fn.glVertexWeighthNV ( a);
}

void OSMesaDriver::nfglVertexWeighthvNV (const GLhalfNV * a)
{
	D(bug("nfosmesa: glVertexWeighthvNV"));
	fn.glVertexWeighthvNV ( a);
}

void OSMesaDriver::nfglVertexAttrib1hNV (GLuint a, GLhalfNV b)
{
	D(bug("nfosmesa: glVertexAttrib1hNV"));
	fn.glVertexAttrib1hNV ( a,  b);
}

void OSMesaDriver::nfglVertexAttrib1hvNV (GLuint a, const GLhalfNV * b)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexAttrib1hvNV"));
	Atari2HostShortPtr(1, (Uint16 *)b, tmp);
	fn.glVertexAttrib1hvNV ( a, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttrib2hNV (GLuint a, GLhalfNV b, GLhalfNV c)
{
	D(bug("nfosmesa: glVertexAttrib2hNV"));
	fn.glVertexAttrib2hNV ( a,  b,  c);
}

void OSMesaDriver::nfglVertexAttrib2hvNV (GLuint a, const GLhalfNV * b)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexAttrib2hvNV"));
	Atari2HostShortPtr(2, (Uint16 *)b, tmp);
	fn.glVertexAttrib2hvNV ( a, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttrib3hNV (GLuint a, GLhalfNV b, GLhalfNV c, GLhalfNV d)
{
	D(bug("nfosmesa: glVertexAttrib3hNV"));
	fn.glVertexAttrib3hNV ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttrib3hvNV (GLuint a, const GLhalfNV * b)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexAttrib3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)b, tmp);
	fn.glVertexAttrib3hvNV ( a, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttrib4hNV (GLuint a, GLhalfNV b, GLhalfNV c, GLhalfNV d, GLhalfNV e)
{
	D(bug("nfosmesa: glVertexAttrib4hNV"));
	fn.glVertexAttrib4hNV ( a,  b,  c,  d,  e);
}

void OSMesaDriver::nfglVertexAttrib4hvNV (GLuint a, const GLhalfNV * b)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttrib4hvNV"));
	Atari2HostShortPtr(4, (Uint16 *)b, tmp);
	fn.glVertexAttrib4hvNV ( a, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttribs1hvNV (GLuint a, GLsizei b, const GLhalfNV * c)
{
	GLshort tmp[1];

	D(bug("nfosmesa: glVertexAttribs1hvNV"));
	Atari2HostShortPtr(1, (Uint16 *)c, tmp);
	fn.glVertexAttribs1hvNV ( a,  b, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttribs2hvNV (GLuint a, GLsizei b, const GLhalfNV * c)
{
	GLshort tmp[2];

	D(bug("nfosmesa: glVertexAttribs2hvNV"));
	Atari2HostShortPtr(2, (Uint16 *)c, tmp);
	fn.glVertexAttribs2hvNV ( a,  b, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttribs3hvNV (GLuint a, GLsizei b, const GLhalfNV * c)
{
	GLshort tmp[3];

	D(bug("nfosmesa: glVertexAttribs3hvNV"));
	Atari2HostShortPtr(3, (Uint16 *)c, tmp);
	fn.glVertexAttribs3hvNV ( a,  b, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglVertexAttribs4hvNV (GLuint a, GLsizei b, const GLhalfNV * c)
{
	GLshort tmp[4];

	D(bug("nfosmesa: glVertexAttribs4hvNV"));
	Atari2HostShortPtr(4, (Uint16 *)c, tmp);
	fn.glVertexAttribs4hvNV ( a,  b, (GLhalfNV *)tmp);
}

void OSMesaDriver::nfglPixelDataRangeNV (GLenum a, GLsizei b, GLvoid * c)
{
	D(bug("nfosmesa: glPixelDataRangeNV"));
	fn.glPixelDataRangeNV ( a,  b,  c);
}

void OSMesaDriver::nfglFlushPixelDataRangeNV (GLenum a)
{
	D(bug("nfosmesa: glFlushPixelDataRangeNV"));
	fn.glFlushPixelDataRangeNV ( a);
}

void OSMesaDriver::nfglPrimitiveRestartNV (void )
{
	D(bug("nfosmesa: glPrimitiveRestartNV"));
	fn.glPrimitiveRestartNV ();
}

void OSMesaDriver::nfglPrimitiveRestartIndexNV (GLuint a)
{
	D(bug("nfosmesa: glPrimitiveRestartIndexNV"));
	fn.glPrimitiveRestartIndexNV ( a);
}

GLvoid* OSMesaDriver::nfglMapObjectBufferATI (GLuint a)
{
	D(bug("nfosmesa: glMapObjectBufferATI"));
	return fn.glMapObjectBufferATI ( a);
}

void OSMesaDriver::nfglUnmapObjectBufferATI (GLuint a)
{
	D(bug("nfosmesa: glUnmapObjectBufferATI"));
	fn.glUnmapObjectBufferATI ( a);
}

void OSMesaDriver::nfglStencilOpSeparateATI (GLenum a, GLenum b, GLenum c, GLenum d)
{
	D(bug("nfosmesa: glStencilOpSeparateATI"));
	fn.glStencilOpSeparateATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglStencilFuncSeparateATI (GLenum a, GLenum b, GLint c, GLuint d)
{
	D(bug("nfosmesa: glStencilFuncSeparateATI"));
	fn.glStencilFuncSeparateATI ( a,  b,  c,  d);
}

void OSMesaDriver::nfglVertexAttribArrayObjectATI (GLuint a, GLint b, GLenum c, GLboolean d, GLsizei e, GLuint f, GLuint g)
{
	D(bug("nfosmesa: glVertexAttribArrayObjectATI"));
	fn.glVertexAttribArrayObjectATI ( a,  b,  c,  d,  e,  f,  g);
}

void OSMesaDriver::nfglGetVertexAttribArrayObjectfvATI (GLuint a, GLenum b, GLfloat * c)
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectfvATI"));
	fn.glGetVertexAttribArrayObjectfvATI ( a,  b,  c);
}

void OSMesaDriver::nfglGetVertexAttribArrayObjectivATI (GLuint a, GLenum b, GLint * c)
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectivATI"));
	fn.glGetVertexAttribArrayObjectivATI ( a,  b,  c);
}

void OSMesaDriver::nfglDepthBoundsEXT (GLclampd a, GLclampd b)
{
	D(bug("nfosmesa: glDepthBoundsEXT"));
	fn.glDepthBoundsEXT ( a,  b);
}

void OSMesaDriver::nfglBlendEquationSeparateEXT (GLenum a, GLenum b)
{
	D(bug("nfosmesa: glBlendEquationSeparateEXT"));
	fn.glBlendEquationSeparateEXT ( a,  b);
}

/* Functions generated: 974 */
