/*
** GLprocs utility for getting function addresses for OpenGL(R) 1.2, 
** OpenGL 1.3, OpenGL 1.4, OpenGL 1.5 and OpenGL extension functions.
**
** Version:  1.1
**
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
** 
** http://oss.sgi.com/projects/FreeB
** 
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
** 
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
** 
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
**
** Initial version of glprocs.{c,h} contributed by Intel(R) Corporation.
*/

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef _WIN32
  #include <windows.h>
  #include "gl.h"  /* Include local "gl.h". Don't include vc32 <GL/gl.h>. */
  #include "glprocs.h"
#else /* GLX */
  #include <GL/gl.h>
  #include <GL/glx.h>
  #include <GL/glprocs.h>
  #define wglGetProcAddress glXGetProcAddressARB
#endif

void* noop(int a, ...)
{
    fprintf(stderr, "Warning!! You are using an unimplemented OpenGL extension");    
    return 0;
}

#define _ASSERT(a) extproc=(void*) noop;//   assert(a)

static void APIENTRY InitBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBlendColor");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBlendColor = extproc;

	glBlendColor(red, green, blue, alpha);
}

static void APIENTRY InitBlendEquation (GLenum mode)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBlendEquation");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBlendEquation = extproc;

	glBlendEquation(mode);
}

static void APIENTRY InitDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDrawRangeElements");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDrawRangeElements = extproc;

	glDrawRangeElements(mode, start, end, count, type, indices);
}

static void APIENTRY InitColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTable");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTable = extproc;

	glColorTable(target, internalformat, width, format, type, table);
}

static void APIENTRY InitColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTableParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTableParameterfv = extproc;

	glColorTableParameterfv(target, pname, params);
}

static void APIENTRY InitColorTableParameteriv (GLenum target, GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTableParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTableParameteriv = extproc;

	glColorTableParameteriv(target, pname, params);
}

static void APIENTRY InitCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyColorTable");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyColorTable = extproc;

	glCopyColorTable(target, internalformat, x, y, width);
}

static void APIENTRY InitGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTable");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTable = extproc;

	glGetColorTable(target, format, type, table);
}

static void APIENTRY InitGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTableParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTableParameterfv = extproc;

	glGetColorTableParameterfv(target, pname, params);
}

static void APIENTRY InitGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTableParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTableParameteriv = extproc;

	glGetColorTableParameteriv(target, pname, params);
}

static void APIENTRY InitColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorSubTable");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorSubTable = extproc;

	glColorSubTable(target, start, count, format, type, data);
}

static void APIENTRY InitCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyColorSubTable");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyColorSubTable = extproc;

	glCopyColorSubTable(target, start, x, y, width);
}

static void APIENTRY InitConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionFilter1D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionFilter1D = extproc;

	glConvolutionFilter1D(target, internalformat, width, format, type, image);
}

static void APIENTRY InitConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionFilter2D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionFilter2D = extproc;

	glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
}

static void APIENTRY InitConvolutionParameterf (GLenum target, GLenum pname, GLfloat params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameterf");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameterf = extproc;

	glConvolutionParameterf(target, pname, params);
}

static void APIENTRY InitConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameterfv = extproc;

	glConvolutionParameterfv(target, pname, params);
}

static void APIENTRY InitConvolutionParameteri (GLenum target, GLenum pname, GLint params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameteri");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameteri = extproc;

	glConvolutionParameteri(target, pname, params);
}

static void APIENTRY InitConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameteriv = extproc;

	glConvolutionParameteriv(target, pname, params);
}

static void APIENTRY InitCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter1D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyConvolutionFilter1D = extproc;

	glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}

static void APIENTRY InitCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter2D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyConvolutionFilter2D = extproc;

	glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}

static void APIENTRY InitGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionFilter");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionFilter = extproc;

	glGetConvolutionFilter(target, format, type, image);
}

static void APIENTRY InitGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionParameterfv = extproc;

	glGetConvolutionParameterfv(target, pname, params);
}

static void APIENTRY InitGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionParameteriv = extproc;

	glGetConvolutionParameteriv(target, pname, params);
}

static void APIENTRY InitGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetSeparableFilter");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetSeparableFilter = extproc;

	glGetSeparableFilter(target, format, type, row, column, span);
}

static void APIENTRY InitSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSeparableFilter2D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSeparableFilter2D = extproc;

	glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
}

static void APIENTRY InitGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogram");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogram = extproc;

	glGetHistogram(target, reset, format, type, values);
}

static void APIENTRY InitGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogramParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogramParameterfv = extproc;

	glGetHistogramParameterfv(target, pname, params);
}

static void APIENTRY InitGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogramParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogramParameteriv = extproc;

	glGetHistogramParameteriv(target, pname, params);
}

static void APIENTRY InitGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmax");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmax = extproc;

	glGetMinmax(target, reset, format, type, values);
}

static void APIENTRY InitGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmaxParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmaxParameterfv = extproc;

	glGetMinmaxParameterfv(target, pname, params);
}

static void APIENTRY InitGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmaxParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmaxParameteriv = extproc;

	glGetMinmaxParameteriv(target, pname, params);
}

static void APIENTRY InitHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glHistogram");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glHistogram = extproc;

	glHistogram(target, width, internalformat, sink);
}

static void APIENTRY InitMinmax (GLenum target, GLenum internalformat, GLboolean sink)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMinmax");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMinmax = extproc;

	glMinmax(target, internalformat, sink);
}

static void APIENTRY InitResetHistogram (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glResetHistogram");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glResetHistogram = extproc;

	glResetHistogram(target);
}

static void APIENTRY InitResetMinmax (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glResetMinmax");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glResetMinmax = extproc;

	glResetMinmax(target);
}

static void APIENTRY InitTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexImage3D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexImage3D = extproc;

	glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

static void APIENTRY InitTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexSubImage3D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexSubImage3D = extproc;

	glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

static void APIENTRY InitCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexSubImage3D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexSubImage3D = extproc;

	glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

static void APIENTRY InitActiveTexture (GLenum texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glActiveTexture");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glActiveTexture = extproc;

	glActiveTexture(texture);
}

static void APIENTRY InitClientActiveTexture (GLenum texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glClientActiveTexture");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glClientActiveTexture = extproc;

	glClientActiveTexture(texture);
}

static void APIENTRY InitMultiTexCoord1d (GLenum target, GLdouble s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1d = extproc;

	glMultiTexCoord1d(target, s);
}

static void APIENTRY InitMultiTexCoord1dv (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1dv = extproc;

	glMultiTexCoord1dv(target, v);
}

static void APIENTRY InitMultiTexCoord1f (GLenum target, GLfloat s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1f = extproc;

	glMultiTexCoord1f(target, s);
}

static void APIENTRY InitMultiTexCoord1fv (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1fv = extproc;

	glMultiTexCoord1fv(target, v);
}

static void APIENTRY InitMultiTexCoord1i (GLenum target, GLint s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1i = extproc;

	glMultiTexCoord1i(target, s);
}

static void APIENTRY InitMultiTexCoord1iv (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1iv = extproc;

	glMultiTexCoord1iv(target, v);
}

static void APIENTRY InitMultiTexCoord1s (GLenum target, GLshort s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1s = extproc;

	glMultiTexCoord1s(target, s);
}

static void APIENTRY InitMultiTexCoord1sv (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1sv = extproc;

	glMultiTexCoord1sv(target, v);
}

static void APIENTRY InitMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2d = extproc;

	glMultiTexCoord2d(target, s, t);
}

static void APIENTRY InitMultiTexCoord2dv (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2dv = extproc;

	glMultiTexCoord2dv(target, v);
}

static void APIENTRY InitMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2f = extproc;

	glMultiTexCoord2f(target, s, t);
}

static void APIENTRY InitMultiTexCoord2fv (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2fv = extproc;

	glMultiTexCoord2fv(target, v);
}

static void APIENTRY InitMultiTexCoord2i (GLenum target, GLint s, GLint t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2i = extproc;

	glMultiTexCoord2i(target, s, t);
}

static void APIENTRY InitMultiTexCoord2iv (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2iv = extproc;

	glMultiTexCoord2iv(target, v);
}

static void APIENTRY InitMultiTexCoord2s (GLenum target, GLshort s, GLshort t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2s = extproc;

	glMultiTexCoord2s(target, s, t);
}

static void APIENTRY InitMultiTexCoord2sv (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2sv = extproc;

	glMultiTexCoord2sv(target, v);
}

static void APIENTRY InitMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3d = extproc;

	glMultiTexCoord3d(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3dv (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3dv = extproc;

	glMultiTexCoord3dv(target, v);
}

static void APIENTRY InitMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3f = extproc;

	glMultiTexCoord3f(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3fv (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3fv = extproc;

	glMultiTexCoord3fv(target, v);
}

static void APIENTRY InitMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3i = extproc;

	glMultiTexCoord3i(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3iv (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3iv = extproc;

	glMultiTexCoord3iv(target, v);
}

static void APIENTRY InitMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3s = extproc;

	glMultiTexCoord3s(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3sv (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3sv = extproc;

	glMultiTexCoord3sv(target, v);
}

static void APIENTRY InitMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4d = extproc;

	glMultiTexCoord4d(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4dv (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4dv = extproc;

	glMultiTexCoord4dv(target, v);
}

static void APIENTRY InitMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4f = extproc;

	glMultiTexCoord4f(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4fv (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4fv = extproc;

	glMultiTexCoord4fv(target, v);
}

static void APIENTRY InitMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4i = extproc;

	glMultiTexCoord4i(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4iv (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4iv = extproc;

	glMultiTexCoord4iv(target, v);
}

static void APIENTRY InitMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4s = extproc;

	glMultiTexCoord4s(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4sv (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4sv = extproc;

	glMultiTexCoord4sv(target, v);
}

static void APIENTRY InitLoadTransposeMatrixf (const GLfloat *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixf");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glLoadTransposeMatrixf = extproc;

	glLoadTransposeMatrixf(m);
}

static void APIENTRY InitLoadTransposeMatrixd (const GLdouble *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixd");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glLoadTransposeMatrixd = extproc;

	glLoadTransposeMatrixd(m);
}

static void APIENTRY InitMultTransposeMatrixf (const GLfloat *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultTransposeMatrixf");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultTransposeMatrixf = extproc;

	glMultTransposeMatrixf(m);
}

static void APIENTRY InitMultTransposeMatrixd (const GLdouble *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultTransposeMatrixd");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultTransposeMatrixd = extproc;

	glMultTransposeMatrixd(m);
}

static void APIENTRY InitSampleCoverage (GLclampf value, GLboolean invert)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSampleCoverage");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSampleCoverage = extproc;

	glSampleCoverage(value, invert);
}

static void APIENTRY InitCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage3D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage3D = extproc;

	glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}

static void APIENTRY InitCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage2D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage2D = extproc;

	glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}

static void APIENTRY InitCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage1D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage1D = extproc;

	glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage3D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage3D = extproc;

	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage2D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage2D = extproc;

	glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage1D");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage1D = extproc;

	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}

static void APIENTRY InitGetCompressedTexImage (GLenum target, GLint level, GLvoid *img)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetCompressedTexImage");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetCompressedTexImage = extproc;

	glGetCompressedTexImage(target, level, img);
}

static void APIENTRY InitBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBlendFuncSeparate");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBlendFuncSeparate = extproc;

	glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

static void APIENTRY InitFogCoordf (GLfloat coord)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glFogCoordf");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glFogCoordf = extproc;

	glFogCoordf(coord);
}

static void APIENTRY InitFogCoordfv (const GLfloat *coord)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glFogCoordfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glFogCoordfv = extproc;

	glFogCoordfv(coord);
}

static void APIENTRY InitFogCoordd (GLdouble coord)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glFogCoordd");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glFogCoordd = extproc;

	glFogCoordd(coord);
}

static void APIENTRY InitFogCoorddv (const GLdouble *coord)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glFogCoorddv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glFogCoorddv = extproc;

	glFogCoorddv(coord);
}

static void APIENTRY InitFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glFogCoordPointer");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glFogCoordPointer = extproc;

	glFogCoordPointer(type, stride, pointer);
}

static void APIENTRY InitMultiDrawArrays (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiDrawArrays");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiDrawArrays = extproc;

	glMultiDrawArrays(mode, first, count, primcount);
}

static void APIENTRY InitMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiDrawElements");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiDrawElements = extproc;

	glMultiDrawElements(mode, count, type, indices, primcount);
}

static void APIENTRY InitPointParameterf (GLenum pname, GLfloat param)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameterf");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameterf = extproc;

	glPointParameterf(pname, param);
}

static void APIENTRY InitPointParameterfv (GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameterfv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameterfv = extproc;

	glPointParameterfv(pname, params);
}

static void APIENTRY InitPointParameteri (GLenum pname, GLint param)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameteri");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameteri = extproc;

	glPointParameteri(pname, param);
}

static void APIENTRY InitPointParameteriv (GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameteriv = extproc;

	glPointParameteriv(pname, params);
}

static void APIENTRY InitSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3b");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3b = extproc;

	glSecondaryColor3b(red, green, blue);
}

static void APIENTRY InitSecondaryColor3bv (const GLbyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3bv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3bv = extproc;

	glSecondaryColor3bv(v);
}

static void APIENTRY InitSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3d = extproc;

	glSecondaryColor3d(red, green, blue);
}

static void APIENTRY InitSecondaryColor3dv (const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3dv = extproc;

	glSecondaryColor3dv(v);
}

static void APIENTRY InitSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3f = extproc;

	glSecondaryColor3f(red, green, blue);
}

static void APIENTRY InitSecondaryColor3fv (const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3fv = extproc;

	glSecondaryColor3fv(v);
}

static void APIENTRY InitSecondaryColor3i (GLint red, GLint green, GLint blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3i = extproc;

	glSecondaryColor3i(red, green, blue);
}

static void APIENTRY InitSecondaryColor3iv (const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3iv = extproc;

	glSecondaryColor3iv(v);
}

static void APIENTRY InitSecondaryColor3s (GLshort red, GLshort green, GLshort blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3s = extproc;

	glSecondaryColor3s(red, green, blue);
}

static void APIENTRY InitSecondaryColor3sv (const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3sv = extproc;

	glSecondaryColor3sv(v);
}

static void APIENTRY InitSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3ub");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3ub = extproc;

	glSecondaryColor3ub(red, green, blue);
}

static void APIENTRY InitSecondaryColor3ubv (const GLubyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3ubv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3ubv = extproc;

	glSecondaryColor3ubv(v);
}

static void APIENTRY InitSecondaryColor3ui (GLuint red, GLuint green, GLuint blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3ui");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3ui = extproc;

	glSecondaryColor3ui(red, green, blue);
}

static void APIENTRY InitSecondaryColor3uiv (const GLuint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3uiv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3uiv = extproc;

	glSecondaryColor3uiv(v);
}

static void APIENTRY InitSecondaryColor3us (GLushort red, GLushort green, GLushort blue)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3us");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3us = extproc;

	glSecondaryColor3us(red, green, blue);
}

static void APIENTRY InitSecondaryColor3usv (const GLushort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColor3usv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColor3usv = extproc;

	glSecondaryColor3usv(v);
}

static void APIENTRY InitSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSecondaryColorPointer");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSecondaryColorPointer = extproc;

	glSecondaryColorPointer(size, type, stride, pointer);
}

static void APIENTRY InitWindowPos2d (GLdouble x, GLdouble y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2d = extproc;

	glWindowPos2d(x, y);
}

static void APIENTRY InitWindowPos2dv (const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2dv = extproc;

	glWindowPos2dv(v);
}

static void APIENTRY InitWindowPos2f (GLfloat x, GLfloat y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2f = extproc;

	glWindowPos2f(x, y);
}

static void APIENTRY InitWindowPos2fv (const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2fv = extproc;

	glWindowPos2fv(v);
}

static void APIENTRY InitWindowPos2i (GLint x, GLint y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2i = extproc;

	glWindowPos2i(x, y);
}

static void APIENTRY InitWindowPos2iv (const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2iv = extproc;

	glWindowPos2iv(v);
}

static void APIENTRY InitWindowPos2s (GLshort x, GLshort y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2s = extproc;

	glWindowPos2s(x, y);
}

static void APIENTRY InitWindowPos2sv (const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2sv = extproc;

	glWindowPos2sv(v);
}

static void APIENTRY InitWindowPos3d (GLdouble x, GLdouble y, GLdouble z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3d");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3d = extproc;

	glWindowPos3d(x, y, z);
}

static void APIENTRY InitWindowPos3dv (const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3dv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3dv = extproc;

	glWindowPos3dv(v);
}

static void APIENTRY InitWindowPos3f (GLfloat x, GLfloat y, GLfloat z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3f");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3f = extproc;

	glWindowPos3f(x, y, z);
}

static void APIENTRY InitWindowPos3fv (const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3fv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3fv = extproc;

	glWindowPos3fv(v);
}

static void APIENTRY InitWindowPos3i (GLint x, GLint y, GLint z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3i");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3i = extproc;

	glWindowPos3i(x, y, z);
}

static void APIENTRY InitWindowPos3iv (const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3iv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3iv = extproc;

	glWindowPos3iv(v);
}

static void APIENTRY InitWindowPos3s (GLshort x, GLshort y, GLshort z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3s");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3s = extproc;

	glWindowPos3s(x, y, z);
}

static void APIENTRY InitWindowPos3sv (const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3sv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3sv = extproc;

	glWindowPos3sv(v);
}

static void APIENTRY InitGenQueries (GLsizei n, GLuint *ids)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenQueries");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenQueries = extproc;

	glGenQueries(n, ids);
}

static void APIENTRY InitDeleteQueries (GLsizei n, const GLuint *ids)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteQueries");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteQueries = extproc;

	glDeleteQueries(n, ids);
}

static GLboolean APIENTRY InitIsQuery (GLuint id)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsQuery");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsQuery = extproc;

	return glIsQuery(id);
}

static void APIENTRY InitBeginQuery (GLenum target, GLuint id)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBeginQuery");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBeginQuery = extproc;

	glBeginQuery(target, id);
}

static void APIENTRY InitEndQuery (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glEndQuery");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glEndQuery = extproc;

	glEndQuery(target);
}

static void APIENTRY InitGetQueryiv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryiv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryiv = extproc;

	glGetQueryiv(target, pname, params);
}

static void APIENTRY InitGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryObjectiv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryObjectiv = extproc;

	glGetQueryObjectiv(id, pname, params);
}

static void APIENTRY InitGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryObjectuiv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryObjectuiv = extproc;

	glGetQueryObjectuiv(id, pname, params);
}

static void APIENTRY InitBindBuffer (GLenum target, GLuint buffer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBindBuffer");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBindBuffer = extproc;

	glBindBuffer(target, buffer);
}

static void APIENTRY InitDeleteBuffers (GLsizei n, const GLuint *buffers)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteBuffers");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteBuffers = extproc;

	glDeleteBuffers(n, buffers);
}

static void APIENTRY InitGenBuffers (GLsizei n, GLuint *buffers)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenBuffers");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenBuffers = extproc;

	glGenBuffers(n, buffers);
}

static GLboolean APIENTRY InitIsBuffer (GLuint buffer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsBuffer");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsBuffer = extproc;

	return glIsBuffer(buffer);
}

static void APIENTRY InitBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBufferData");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBufferData = extproc;

	glBufferData(target, size, data, usage);
}

static void APIENTRY InitBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBufferSubData");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBufferSubData = extproc;

	glBufferSubData(target, offset, size, data);
}

static void APIENTRY InitGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferSubData");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferSubData = extproc;

	glGetBufferSubData(target, offset, size, data);
}

static GLvoid* APIENTRY InitMapBuffer (GLenum target, GLenum access)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMapBuffer");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glMapBuffer = extproc;

	return glMapBuffer(target, access);
}

static GLboolean APIENTRY InitUnmapBuffer (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUnmapBuffer");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glUnmapBuffer = extproc;

	return glUnmapBuffer(target);
}

static void APIENTRY InitGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferParameteriv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferParameteriv = extproc;

	glGetBufferParameteriv(target, pname, params);
}

static void APIENTRY InitGetBufferPointerv (GLenum target, GLenum pname, GLvoid* *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferPointerv");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferPointerv = extproc;

	glGetBufferPointerv(target, pname, params);
}

static void APIENTRY InitActiveTextureARB (GLenum texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glActiveTextureARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glActiveTextureARB = extproc;

	glActiveTextureARB(texture);
}

static void APIENTRY InitClientActiveTextureARB (GLenum texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glClientActiveTextureARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glClientActiveTextureARB = extproc;

	glClientActiveTextureARB(texture);
}

static void APIENTRY InitMultiTexCoord1dARB (GLenum target, GLdouble s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1dARB = extproc;

	glMultiTexCoord1dARB(target, s);
}

static void APIENTRY InitMultiTexCoord1dvARB (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1dvARB = extproc;

	glMultiTexCoord1dvARB(target, v);
}

static void APIENTRY InitMultiTexCoord1fARB (GLenum target, GLfloat s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1fARB = extproc;

	glMultiTexCoord1fARB(target, s);
}

static void APIENTRY InitMultiTexCoord1fvARB (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1fvARB = extproc;

	glMultiTexCoord1fvARB(target, v);
}

static void APIENTRY InitMultiTexCoord1iARB (GLenum target, GLint s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1iARB = extproc;

	glMultiTexCoord1iARB(target, s);
}

static void APIENTRY InitMultiTexCoord1ivARB (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1ivARB = extproc;

	glMultiTexCoord1ivARB(target, v);
}

static void APIENTRY InitMultiTexCoord1sARB (GLenum target, GLshort s)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1sARB = extproc;

	glMultiTexCoord1sARB(target, s);
}

static void APIENTRY InitMultiTexCoord1svARB (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord1svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord1svARB = extproc;

	glMultiTexCoord1svARB(target, v);
}

static void APIENTRY InitMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2dARB = extproc;

	glMultiTexCoord2dARB(target, s, t);
}

static void APIENTRY InitMultiTexCoord2dvARB (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2dvARB = extproc;

	glMultiTexCoord2dvARB(target, v);
}

static void APIENTRY InitMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2fARB = extproc;

	glMultiTexCoord2fARB(target, s, t);
}

static void APIENTRY InitMultiTexCoord2fvARB (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2fvARB = extproc;

	glMultiTexCoord2fvARB(target, v);
}

static void APIENTRY InitMultiTexCoord2iARB (GLenum target, GLint s, GLint t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2iARB = extproc;

	glMultiTexCoord2iARB(target, s, t);
}

static void APIENTRY InitMultiTexCoord2ivARB (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2ivARB = extproc;

	glMultiTexCoord2ivARB(target, v);
}

static void APIENTRY InitMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2sARB = extproc;

	glMultiTexCoord2sARB(target, s, t);
}

static void APIENTRY InitMultiTexCoord2svARB (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord2svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord2svARB = extproc;

	glMultiTexCoord2svARB(target, v);
}

static void APIENTRY InitMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3dARB = extproc;

	glMultiTexCoord3dARB(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3dvARB (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3dvARB = extproc;

	glMultiTexCoord3dvARB(target, v);
}

static void APIENTRY InitMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3fARB = extproc;

	glMultiTexCoord3fARB(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3fvARB (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3fvARB = extproc;

	glMultiTexCoord3fvARB(target, v);
}

static void APIENTRY InitMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3iARB = extproc;

	glMultiTexCoord3iARB(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3ivARB (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3ivARB = extproc;

	glMultiTexCoord3ivARB(target, v);
}

static void APIENTRY InitMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3sARB = extproc;

	glMultiTexCoord3sARB(target, s, t, r);
}

static void APIENTRY InitMultiTexCoord3svARB (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord3svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord3svARB = extproc;

	glMultiTexCoord3svARB(target, v);
}

static void APIENTRY InitMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4dARB = extproc;

	glMultiTexCoord4dARB(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4dvARB (GLenum target, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4dvARB = extproc;

	glMultiTexCoord4dvARB(target, v);
}

static void APIENTRY InitMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4fARB = extproc;

	glMultiTexCoord4fARB(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4fvARB (GLenum target, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4fvARB = extproc;

	glMultiTexCoord4fvARB(target, v);
}

static void APIENTRY InitMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4iARB = extproc;

	glMultiTexCoord4iARB(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4ivARB (GLenum target, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4ivARB = extproc;

	glMultiTexCoord4ivARB(target, v);
}

static void APIENTRY InitMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4sARB = extproc;

	glMultiTexCoord4sARB(target, s, t, r, q);
}

static void APIENTRY InitMultiTexCoord4svARB (GLenum target, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultiTexCoord4svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultiTexCoord4svARB = extproc;

	glMultiTexCoord4svARB(target, v);
}

static void APIENTRY InitLoadTransposeMatrixfARB (const GLfloat *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixfARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glLoadTransposeMatrixfARB = extproc;

	glLoadTransposeMatrixfARB(m);
}

static void APIENTRY InitLoadTransposeMatrixdARB (const GLdouble *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glLoadTransposeMatrixdARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glLoadTransposeMatrixdARB = extproc;

	glLoadTransposeMatrixdARB(m);
}

static void APIENTRY InitMultTransposeMatrixfARB (const GLfloat *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultTransposeMatrixfARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultTransposeMatrixfARB = extproc;

	glMultTransposeMatrixfARB(m);
}

static void APIENTRY InitMultTransposeMatrixdARB (const GLdouble *m)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMultTransposeMatrixdARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMultTransposeMatrixdARB = extproc;

	glMultTransposeMatrixdARB(m);
}

static void APIENTRY InitSampleCoverageARB (GLclampf value, GLboolean invert)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSampleCoverageARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSampleCoverageARB = extproc;

	glSampleCoverageARB(value, invert);
}

static void APIENTRY InitCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage3DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage3DARB = extproc;

	glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
}

static void APIENTRY InitCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage2DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage2DARB = extproc;

	glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);
}

static void APIENTRY InitCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexImage1DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexImage1DARB = extproc;

	glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage3DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage3DARB = extproc;

	glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage2DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage2DARB = extproc;

	glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

static void APIENTRY InitCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompressedTexSubImage1DARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompressedTexSubImage1DARB = extproc;

	glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);
}

static void APIENTRY InitGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetCompressedTexImageARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetCompressedTexImageARB = extproc;

	glGetCompressedTexImageARB(target, level, img);
}

static void APIENTRY InitPointParameterfARB (GLenum pname, GLfloat param)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameterfARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameterfARB = extproc;

	glPointParameterfARB(pname, param);
}

static void APIENTRY InitPointParameterfvARB (GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPointParameterfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPointParameterfvARB = extproc;

	glPointParameterfvARB(pname, params);
}

static void APIENTRY InitWeightbvARB (GLint size, const GLbyte *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightbvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightbvARB = extproc;

	glWeightbvARB(size, weights);
}

static void APIENTRY InitWeightsvARB (GLint size, const GLshort *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightsvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightsvARB = extproc;

	glWeightsvARB(size, weights);
}

static void APIENTRY InitWeightivARB (GLint size, const GLint *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightivARB = extproc;

	glWeightivARB(size, weights);
}

static void APIENTRY InitWeightfvARB (GLint size, const GLfloat *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightfvARB = extproc;

	glWeightfvARB(size, weights);
}

static void APIENTRY InitWeightdvARB (GLint size, const GLdouble *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightdvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightdvARB = extproc;

	glWeightdvARB(size, weights);
}

static void APIENTRY InitWeightubvARB (GLint size, const GLubyte *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightubvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightubvARB = extproc;

	glWeightubvARB(size, weights);
}

static void APIENTRY InitWeightusvARB (GLint size, const GLushort *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightusvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightusvARB = extproc;

	glWeightusvARB(size, weights);
}

static void APIENTRY InitWeightuivARB (GLint size, const GLuint *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightuivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightuivARB = extproc;

	glWeightuivARB(size, weights);
}

static void APIENTRY InitWeightPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWeightPointerARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWeightPointerARB = extproc;

	glWeightPointerARB(size, type, stride, pointer);
}

static void APIENTRY InitVertexBlendARB (GLint count)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexBlendARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexBlendARB = extproc;

	glVertexBlendARB(count);
}

static void APIENTRY InitCurrentPaletteMatrixARB (GLint index)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCurrentPaletteMatrixARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCurrentPaletteMatrixARB = extproc;

	glCurrentPaletteMatrixARB(index);
}

static void APIENTRY InitMatrixIndexubvARB (GLint size, const GLubyte *indices)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMatrixIndexubvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMatrixIndexubvARB = extproc;

	glMatrixIndexubvARB(size, indices);
}

static void APIENTRY InitMatrixIndexusvARB (GLint size, const GLushort *indices)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMatrixIndexusvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMatrixIndexusvARB = extproc;

	glMatrixIndexusvARB(size, indices);
}

static void APIENTRY InitMatrixIndexuivARB (GLint size, const GLuint *indices)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMatrixIndexuivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMatrixIndexuivARB = extproc;

	glMatrixIndexuivARB(size, indices);
}

static void APIENTRY InitMatrixIndexPointerARB (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMatrixIndexPointerARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMatrixIndexPointerARB = extproc;

	glMatrixIndexPointerARB(size, type, stride, pointer);
}

static void APIENTRY InitWindowPos2dARB (GLdouble x, GLdouble y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2dARB = extproc;

	glWindowPos2dARB(x, y);
}

static void APIENTRY InitWindowPos2dvARB (const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2dvARB = extproc;

	glWindowPos2dvARB(v);
}

static void APIENTRY InitWindowPos2fARB (GLfloat x, GLfloat y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2fARB = extproc;

	glWindowPos2fARB(x, y);
}

static void APIENTRY InitWindowPos2fvARB (const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2fvARB = extproc;

	glWindowPos2fvARB(v);
}

static void APIENTRY InitWindowPos2iARB (GLint x, GLint y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2iARB = extproc;

	glWindowPos2iARB(x, y);
}

static void APIENTRY InitWindowPos2ivARB (const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2ivARB = extproc;

	glWindowPos2ivARB(v);
}

static void APIENTRY InitWindowPos2sARB (GLshort x, GLshort y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2sARB = extproc;

	glWindowPos2sARB(x, y);
}

static void APIENTRY InitWindowPos2svARB (const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos2svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos2svARB = extproc;

	glWindowPos2svARB(v);
}

static void APIENTRY InitWindowPos3dARB (GLdouble x, GLdouble y, GLdouble z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3dARB = extproc;

	glWindowPos3dARB(x, y, z);
}

static void APIENTRY InitWindowPos3dvARB (const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3dvARB = extproc;

	glWindowPos3dvARB(v);
}

static void APIENTRY InitWindowPos3fARB (GLfloat x, GLfloat y, GLfloat z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3fARB = extproc;

	glWindowPos3fARB(x, y, z);
}

static void APIENTRY InitWindowPos3fvARB (const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3fvARB = extproc;

	glWindowPos3fvARB(v);
}

static void APIENTRY InitWindowPos3iARB (GLint x, GLint y, GLint z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3iARB = extproc;

	glWindowPos3iARB(x, y, z);
}

static void APIENTRY InitWindowPos3ivARB (const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3ivARB = extproc;

	glWindowPos3ivARB(v);
}

static void APIENTRY InitWindowPos3sARB (GLshort x, GLshort y, GLshort z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3sARB = extproc;

	glWindowPos3sARB(x, y, z);
}

static void APIENTRY InitWindowPos3svARB (const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glWindowPos3svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glWindowPos3svARB = extproc;

	glWindowPos3svARB(v);
}

static void APIENTRY InitVertexAttrib1dARB (GLuint index, GLdouble x)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1dARB = extproc;

	glVertexAttrib1dARB(index, x);
}

static void APIENTRY InitVertexAttrib1dvARB (GLuint index, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1dvARB = extproc;

	glVertexAttrib1dvARB(index, v);
}

static void APIENTRY InitVertexAttrib1fARB (GLuint index, GLfloat x)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1fARB = extproc;

	glVertexAttrib1fARB(index, x);
}

static void APIENTRY InitVertexAttrib1fvARB (GLuint index, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1fvARB = extproc;

	glVertexAttrib1fvARB(index, v);
}

static void APIENTRY InitVertexAttrib1sARB (GLuint index, GLshort x)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1sARB = extproc;

	glVertexAttrib1sARB(index, x);
}

static void APIENTRY InitVertexAttrib1svARB (GLuint index, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib1svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib1svARB = extproc;

	glVertexAttrib1svARB(index, v);
}

static void APIENTRY InitVertexAttrib2dARB (GLuint index, GLdouble x, GLdouble y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2dARB = extproc;

	glVertexAttrib2dARB(index, x, y);
}

static void APIENTRY InitVertexAttrib2dvARB (GLuint index, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2dvARB = extproc;

	glVertexAttrib2dvARB(index, v);
}

static void APIENTRY InitVertexAttrib2fARB (GLuint index, GLfloat x, GLfloat y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2fARB = extproc;

	glVertexAttrib2fARB(index, x, y);
}

static void APIENTRY InitVertexAttrib2fvARB (GLuint index, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2fvARB = extproc;

	glVertexAttrib2fvARB(index, v);
}

static void APIENTRY InitVertexAttrib2sARB (GLuint index, GLshort x, GLshort y)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2sARB = extproc;

	glVertexAttrib2sARB(index, x, y);
}

static void APIENTRY InitVertexAttrib2svARB (GLuint index, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib2svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib2svARB = extproc;

	glVertexAttrib2svARB(index, v);
}

static void APIENTRY InitVertexAttrib3dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3dARB = extproc;

	glVertexAttrib3dARB(index, x, y, z);
}

static void APIENTRY InitVertexAttrib3dvARB (GLuint index, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3dvARB = extproc;

	glVertexAttrib3dvARB(index, v);
}

static void APIENTRY InitVertexAttrib3fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3fARB = extproc;

	glVertexAttrib3fARB(index, x, y, z);
}

static void APIENTRY InitVertexAttrib3fvARB (GLuint index, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3fvARB = extproc;

	glVertexAttrib3fvARB(index, v);
}

static void APIENTRY InitVertexAttrib3sARB (GLuint index, GLshort x, GLshort y, GLshort z)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3sARB = extproc;

	glVertexAttrib3sARB(index, x, y, z);
}

static void APIENTRY InitVertexAttrib3svARB (GLuint index, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib3svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib3svARB = extproc;

	glVertexAttrib3svARB(index, v);
}

static void APIENTRY InitVertexAttrib4NbvARB (GLuint index, const GLbyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NbvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NbvARB = extproc;

	glVertexAttrib4NbvARB(index, v);
}

static void APIENTRY InitVertexAttrib4NivARB (GLuint index, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NivARB = extproc;

	glVertexAttrib4NivARB(index, v);
}

static void APIENTRY InitVertexAttrib4NsvARB (GLuint index, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NsvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NsvARB = extproc;

	glVertexAttrib4NsvARB(index, v);
}

static void APIENTRY InitVertexAttrib4NubARB (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NubARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NubARB = extproc;

	glVertexAttrib4NubARB(index, x, y, z, w);
}

static void APIENTRY InitVertexAttrib4NubvARB (GLuint index, const GLubyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NubvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NubvARB = extproc;

	glVertexAttrib4NubvARB(index, v);
}

static void APIENTRY InitVertexAttrib4NuivARB (GLuint index, const GLuint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NuivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NuivARB = extproc;

	glVertexAttrib4NuivARB(index, v);
}

static void APIENTRY InitVertexAttrib4NusvARB (GLuint index, const GLushort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4NusvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4NusvARB = extproc;

	glVertexAttrib4NusvARB(index, v);
}

static void APIENTRY InitVertexAttrib4bvARB (GLuint index, const GLbyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4bvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4bvARB = extproc;

	glVertexAttrib4bvARB(index, v);
}

static void APIENTRY InitVertexAttrib4dARB (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4dARB = extproc;

	glVertexAttrib4dARB(index, x, y, z, w);
}

static void APIENTRY InitVertexAttrib4dvARB (GLuint index, const GLdouble *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4dvARB = extproc;

	glVertexAttrib4dvARB(index, v);
}

static void APIENTRY InitVertexAttrib4fARB (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4fARB = extproc;

	glVertexAttrib4fARB(index, x, y, z, w);
}

static void APIENTRY InitVertexAttrib4fvARB (GLuint index, const GLfloat *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4fvARB = extproc;

	glVertexAttrib4fvARB(index, v);
}

static void APIENTRY InitVertexAttrib4ivARB (GLuint index, const GLint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4ivARB = extproc;

	glVertexAttrib4ivARB(index, v);
}

static void APIENTRY InitVertexAttrib4sARB (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4sARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4sARB = extproc;

	glVertexAttrib4sARB(index, x, y, z, w);
}

static void APIENTRY InitVertexAttrib4svARB (GLuint index, const GLshort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4svARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4svARB = extproc;

	glVertexAttrib4svARB(index, v);
}

static void APIENTRY InitVertexAttrib4ubvARB (GLuint index, const GLubyte *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4ubvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4ubvARB = extproc;

	glVertexAttrib4ubvARB(index, v);
}

static void APIENTRY InitVertexAttrib4uivARB (GLuint index, const GLuint *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4uivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4uivARB = extproc;

	glVertexAttrib4uivARB(index, v);
}

static void APIENTRY InitVertexAttrib4usvARB (GLuint index, const GLushort *v)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttrib4usvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttrib4usvARB = extproc;

	glVertexAttrib4usvARB(index, v);
}

static void APIENTRY InitVertexAttribPointerARB (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glVertexAttribPointerARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glVertexAttribPointerARB = extproc;

	glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);
}

static void APIENTRY InitEnableVertexAttribArrayARB (GLuint index)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glEnableVertexAttribArrayARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glEnableVertexAttribArrayARB = extproc;

	glEnableVertexAttribArrayARB(index);
}

static void APIENTRY InitDisableVertexAttribArrayARB (GLuint index)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDisableVertexAttribArrayARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDisableVertexAttribArrayARB = extproc;

	glDisableVertexAttribArrayARB(index);
}

static void APIENTRY InitProgramStringARB (GLenum target, GLenum format, GLsizei len, const GLvoid *string)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramStringARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramStringARB = extproc;

	glProgramStringARB(target, format, len, string);
}

static void APIENTRY InitBindProgramARB (GLenum target, GLuint program)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBindProgramARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBindProgramARB = extproc;

	glBindProgramARB(target, program);
}

static void APIENTRY InitDeleteProgramsARB (GLsizei n, const GLuint *programs)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteProgramsARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteProgramsARB = extproc;

	glDeleteProgramsARB(n, programs);
}

static void APIENTRY InitGenProgramsARB (GLsizei n, GLuint *programs)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenProgramsARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenProgramsARB = extproc;

	glGenProgramsARB(n, programs);
}

static void APIENTRY InitProgramEnvParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramEnvParameter4dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramEnvParameter4dARB = extproc;

	glProgramEnvParameter4dARB(target, index, x, y, z, w);
}

static void APIENTRY InitProgramEnvParameter4dvARB (GLenum target, GLuint index, const GLdouble *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramEnvParameter4dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramEnvParameter4dvARB = extproc;

	glProgramEnvParameter4dvARB(target, index, params);
}

static void APIENTRY InitProgramEnvParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramEnvParameter4fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramEnvParameter4fARB = extproc;

	glProgramEnvParameter4fARB(target, index, x, y, z, w);
}

static void APIENTRY InitProgramEnvParameter4fvARB (GLenum target, GLuint index, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramEnvParameter4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramEnvParameter4fvARB = extproc;

	glProgramEnvParameter4fvARB(target, index, params);
}

static void APIENTRY InitProgramLocalParameter4dARB (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramLocalParameter4dARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramLocalParameter4dARB = extproc;

	glProgramLocalParameter4dARB(target, index, x, y, z, w);
}

static void APIENTRY InitProgramLocalParameter4dvARB (GLenum target, GLuint index, const GLdouble *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramLocalParameter4dvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramLocalParameter4dvARB = extproc;

	glProgramLocalParameter4dvARB(target, index, params);
}

static void APIENTRY InitProgramLocalParameter4fARB (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramLocalParameter4fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramLocalParameter4fARB = extproc;

	glProgramLocalParameter4fARB(target, index, x, y, z, w);
}

static void APIENTRY InitProgramLocalParameter4fvARB (GLenum target, GLuint index, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glProgramLocalParameter4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glProgramLocalParameter4fvARB = extproc;

	glProgramLocalParameter4fvARB(target, index, params);
}

static void APIENTRY InitGetProgramEnvParameterdvARB (GLenum target, GLuint index, GLdouble *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramEnvParameterdvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramEnvParameterdvARB = extproc;

	glGetProgramEnvParameterdvARB(target, index, params);
}

static void APIENTRY InitGetProgramEnvParameterfvARB (GLenum target, GLuint index, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramEnvParameterfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramEnvParameterfvARB = extproc;

	glGetProgramEnvParameterfvARB(target, index, params);
}

static void APIENTRY InitGetProgramLocalParameterdvARB (GLenum target, GLuint index, GLdouble *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramLocalParameterdvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramLocalParameterdvARB = extproc;

	glGetProgramLocalParameterdvARB(target, index, params);
}

static void APIENTRY InitGetProgramLocalParameterfvARB (GLenum target, GLuint index, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramLocalParameterfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramLocalParameterfvARB = extproc;

	glGetProgramLocalParameterfvARB(target, index, params);
}

static void APIENTRY InitGetProgramivARB (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramivARB = extproc;

	glGetProgramivARB(target, pname, params);
}

static void APIENTRY InitGetProgramStringARB (GLenum target, GLenum pname, GLvoid *string)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetProgramStringARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetProgramStringARB = extproc;

	glGetProgramStringARB(target, pname, string);
}

static void APIENTRY InitGetVertexAttribdvARB (GLuint index, GLenum pname, GLdouble *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetVertexAttribdvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetVertexAttribdvARB = extproc;

	glGetVertexAttribdvARB(index, pname, params);
}

static void APIENTRY InitGetVertexAttribfvARB (GLuint index, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetVertexAttribfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetVertexAttribfvARB = extproc;

	glGetVertexAttribfvARB(index, pname, params);
}

static void APIENTRY InitGetVertexAttribivARB (GLuint index, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetVertexAttribivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetVertexAttribivARB = extproc;

	glGetVertexAttribivARB(index, pname, params);
}

static void APIENTRY InitGetVertexAttribPointervARB (GLuint index, GLenum pname, GLvoid* *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetVertexAttribPointervARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetVertexAttribPointervARB = extproc;

	glGetVertexAttribPointervARB(index, pname, pointer);
}

static GLboolean APIENTRY InitIsProgramARB (GLuint program)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsProgramARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsProgramARB = extproc;

	return glIsProgramARB(program);
}

static void APIENTRY InitBindBufferARB (GLenum target, GLuint buffer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBindBufferARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBindBufferARB = extproc;

	glBindBufferARB(target, buffer);
}

static void APIENTRY InitDeleteBuffersARB (GLsizei n, const GLuint *buffers)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteBuffersARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteBuffersARB = extproc;

	glDeleteBuffersARB(n, buffers);
}

static void APIENTRY InitGenBuffersARB (GLsizei n, GLuint *buffers)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenBuffersARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenBuffersARB = extproc;

	glGenBuffersARB(n, buffers);
}

static GLboolean APIENTRY InitIsBufferARB (GLuint buffer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsBufferARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsBufferARB = extproc;

	return glIsBufferARB(buffer);
}

static void APIENTRY InitBufferDataARB (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBufferDataARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBufferDataARB = extproc;

	glBufferDataARB(target, size, data, usage);
}

static void APIENTRY InitBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBufferSubDataARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBufferSubDataARB = extproc;

	glBufferSubDataARB(target, offset, size, data);
}

static void APIENTRY InitGetBufferSubDataARB (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferSubDataARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferSubDataARB = extproc;

	glGetBufferSubDataARB(target, offset, size, data);
}

static GLvoid* APIENTRY InitMapBufferARB (GLenum target, GLenum access)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMapBufferARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glMapBufferARB = extproc;

	return glMapBufferARB(target, access);
}

static GLboolean APIENTRY InitUnmapBufferARB (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUnmapBufferARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glUnmapBufferARB = extproc;

	return glUnmapBufferARB(target);
}

static void APIENTRY InitGetBufferParameterivARB (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferParameterivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferParameterivARB = extproc;

	glGetBufferParameterivARB(target, pname, params);
}

static void APIENTRY InitGetBufferPointervARB (GLenum target, GLenum pname, GLvoid* *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetBufferPointervARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetBufferPointervARB = extproc;

	glGetBufferPointervARB(target, pname, params);
}

static void APIENTRY InitGenQueriesARB (GLsizei n, GLuint *ids)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenQueriesARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenQueriesARB = extproc;

	glGenQueriesARB(n, ids);
}

static void APIENTRY InitDeleteQueriesARB (GLsizei n, const GLuint *ids)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteQueriesARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteQueriesARB = extproc;

	glDeleteQueriesARB(n, ids);
}

static GLboolean APIENTRY InitIsQueryARB (GLuint id)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsQueryARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsQueryARB = extproc;

	return glIsQueryARB(id);
}

static void APIENTRY InitBeginQueryARB (GLenum target, GLuint id)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBeginQueryARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBeginQueryARB = extproc;

	glBeginQueryARB(target, id);
}

static void APIENTRY InitEndQueryARB (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glEndQueryARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glEndQueryARB = extproc;

	glEndQueryARB(target);
}

static void APIENTRY InitGetQueryivARB (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryivARB = extproc;

	glGetQueryivARB(target, pname, params);
}

static void APIENTRY InitGetQueryObjectivARB (GLuint id, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryObjectivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryObjectivARB = extproc;

	glGetQueryObjectivARB(id, pname, params);
}

static void APIENTRY InitGetQueryObjectuivARB (GLuint id, GLenum pname, GLuint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetQueryObjectuivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetQueryObjectuivARB = extproc;

	glGetQueryObjectuivARB(id, pname, params);
}

static void APIENTRY InitDeleteObjectARB (GLhandleARB obj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteObjectARB = extproc;

	glDeleteObjectARB(obj);
}

static GLhandleARB APIENTRY InitGetHandleARB (GLenum pname)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHandleARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glGetHandleARB = extproc;

	return glGetHandleARB(pname);
}

static void APIENTRY InitDetachObjectARB (GLhandleARB containerObj, GLhandleARB attachedObj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDetachObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDetachObjectARB = extproc;

	glDetachObjectARB(containerObj, attachedObj);
}

static GLhandleARB APIENTRY InitCreateShaderObjectARB (GLenum shaderType)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCreateShaderObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glCreateShaderObjectARB = extproc;

	return glCreateShaderObjectARB(shaderType);
}

static void APIENTRY InitShaderSourceARB (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glShaderSourceARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glShaderSourceARB = extproc;

	glShaderSourceARB(shaderObj, count, string, length);
}

static void APIENTRY InitCompileShaderARB (GLhandleARB shaderObj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCompileShaderARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCompileShaderARB = extproc;

	glCompileShaderARB(shaderObj);
}

static GLhandleARB APIENTRY InitCreateProgramObjectARB (void)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCreateProgramObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glCreateProgramObjectARB = extproc;

	return glCreateProgramObjectARB();
}

static void APIENTRY InitAttachObjectARB (GLhandleARB containerObj, GLhandleARB obj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glAttachObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glAttachObjectARB = extproc;

	glAttachObjectARB(containerObj, obj);
}

static void APIENTRY InitLinkProgramARB (GLhandleARB programObj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glLinkProgramARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glLinkProgramARB = extproc;

	glLinkProgramARB(programObj);
}

static void APIENTRY InitUseProgramObjectARB (GLhandleARB programObj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUseProgramObjectARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUseProgramObjectARB = extproc;

	glUseProgramObjectARB(programObj);
}

static void APIENTRY InitValidateProgramARB (GLhandleARB programObj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glValidateProgramARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glValidateProgramARB = extproc;

	glValidateProgramARB(programObj);
}

static void APIENTRY InitUniform1fARB (GLint location, GLfloat v0)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform1fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform1fARB = extproc;

	glUniform1fARB(location, v0);
}

static void APIENTRY InitUniform2fARB (GLint location, GLfloat v0, GLfloat v1)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform2fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform2fARB = extproc;

	glUniform2fARB(location, v0, v1);
}

static void APIENTRY InitUniform3fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform3fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform3fARB = extproc;

	glUniform3fARB(location, v0, v1, v2);
}

static void APIENTRY InitUniform4fARB (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform4fARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform4fARB = extproc;

	glUniform4fARB(location, v0, v1, v2, v3);
}

static void APIENTRY InitUniform1iARB (GLint location, GLint v0)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform1iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform1iARB = extproc;

	glUniform1iARB(location, v0);
}

static void APIENTRY InitUniform2iARB (GLint location, GLint v0, GLint v1)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform2iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform2iARB = extproc;

	glUniform2iARB(location, v0, v1);
}

static void APIENTRY InitUniform3iARB (GLint location, GLint v0, GLint v1, GLint v2)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform3iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform3iARB = extproc;

	glUniform3iARB(location, v0, v1, v2);
}

static void APIENTRY InitUniform4iARB (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform4iARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform4iARB = extproc;

	glUniform4iARB(location, v0, v1, v2, v3);
}

static void APIENTRY InitUniform1fvARB (GLint location, GLsizei count, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform1fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform1fvARB = extproc;

	glUniform1fvARB(location, count, value);
}

static void APIENTRY InitUniform2fvARB (GLint location, GLsizei count, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform2fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform2fvARB = extproc;

	glUniform2fvARB(location, count, value);
}

static void APIENTRY InitUniform3fvARB (GLint location, GLsizei count, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform3fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform3fvARB = extproc;

	glUniform3fvARB(location, count, value);
}

static void APIENTRY InitUniform4fvARB (GLint location, GLsizei count, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform4fvARB = extproc;

	glUniform4fvARB(location, count, value);
}

static void APIENTRY InitUniform1ivARB (GLint location, GLsizei count, const GLint *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform1ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform1ivARB = extproc;

	glUniform1ivARB(location, count, value);
}

static void APIENTRY InitUniform2ivARB (GLint location, GLsizei count, const GLint *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform2ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform2ivARB = extproc;

	glUniform2ivARB(location, count, value);
}

static void APIENTRY InitUniform3ivARB (GLint location, GLsizei count, const GLint *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform3ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform3ivARB = extproc;

	glUniform3ivARB(location, count, value);
}

static void APIENTRY InitUniform4ivARB (GLint location, GLsizei count, const GLint *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniform4ivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniform4ivARB = extproc;

	glUniform4ivARB(location, count, value);
}

static void APIENTRY InitUniformMatrix2fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniformMatrix2fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniformMatrix2fvARB = extproc;

	glUniformMatrix2fvARB(location, count, transpose, value);
}

static void APIENTRY InitUniformMatrix3fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniformMatrix3fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniformMatrix3fvARB = extproc;

	glUniformMatrix3fvARB(location, count, transpose, value);
}

static void APIENTRY InitUniformMatrix4fvARB (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glUniformMatrix4fvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glUniformMatrix4fvARB = extproc;

	glUniformMatrix4fvARB(location, count, transpose, value);
}

static void APIENTRY InitGetObjectParameterfvARB (GLhandleARB obj, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetObjectParameterfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetObjectParameterfvARB = extproc;

	glGetObjectParameterfvARB(obj, pname, params);
}

static void APIENTRY InitGetObjectParameterivARB (GLhandleARB obj, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetObjectParameterivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetObjectParameterivARB = extproc;

	glGetObjectParameterivARB(obj, pname, params);
}

static void APIENTRY InitGetInfoLogARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetInfoLogARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetInfoLogARB = extproc;

	glGetInfoLogARB(obj, maxLength, length, infoLog);
}

static void APIENTRY InitGetAttachedObjectsARB (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetAttachedObjectsARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetAttachedObjectsARB = extproc;

	glGetAttachedObjectsARB(containerObj, maxCount, count, obj);
}

static GLint APIENTRY InitGetUniformLocationARB (GLhandleARB programObj, const GLcharARB *name)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetUniformLocationARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glGetUniformLocationARB = extproc;

	return glGetUniformLocationARB(programObj, name);
}

static void APIENTRY InitGetActiveUniformARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetActiveUniformARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetActiveUniformARB = extproc;

	glGetActiveUniformARB(programObj, index, maxLength, length, size, type, name);
}

static void APIENTRY InitGetUniformfvARB (GLhandleARB programObj, GLint location, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetUniformfvARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetUniformfvARB = extproc;

	glGetUniformfvARB(programObj, location, params);
}

static void APIENTRY InitGetUniformivARB (GLhandleARB programObj, GLint location, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetUniformivARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetUniformivARB = extproc;

	glGetUniformivARB(programObj, location, params);
}

static void APIENTRY InitGetShaderSourceARB (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetShaderSourceARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetShaderSourceARB = extproc;

	glGetShaderSourceARB(obj, maxLength, length, source);
}

static void APIENTRY InitBindAttribLocationARB (GLhandleARB programObj, GLuint index, const GLcharARB *name)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBindAttribLocationARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBindAttribLocationARB = extproc;

	glBindAttribLocationARB(programObj, index, name);
}

static void APIENTRY InitGetActiveAttribARB (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetActiveAttribARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetActiveAttribARB = extproc;

	glGetActiveAttribARB(programObj, index, maxLength, length, size, type, name);
}

static GLint APIENTRY InitGetAttribLocationARB (GLhandleARB programObj, const GLcharARB *name)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetAttribLocationARB");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glGetAttribLocationARB = extproc;

	return glGetAttribLocationARB(programObj, name);
}

static void APIENTRY InitBlendColorEXT (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBlendColorEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBlendColorEXT = extproc;

	glBlendColorEXT(red, green, blue, alpha);
}

static void APIENTRY InitPolygonOffsetEXT (GLfloat factor, GLfloat bias)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPolygonOffsetEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPolygonOffsetEXT = extproc;

	glPolygonOffsetEXT(factor, bias);
}

static void APIENTRY InitTexImage3DEXT (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexImage3DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexImage3DEXT = extproc;

	glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

static void APIENTRY InitTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexSubImage3DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexSubImage3DEXT = extproc;

	glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

static void APIENTRY InitGetTexFilterFuncSGIS (GLenum target, GLenum filter, GLfloat *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetTexFilterFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetTexFilterFuncSGIS = extproc;

	glGetTexFilterFuncSGIS(target, filter, weights);
}

static void APIENTRY InitTexFilterFuncSGIS (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexFilterFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexFilterFuncSGIS = extproc;

	glTexFilterFuncSGIS(target, filter, n, weights);
}

static void APIENTRY InitTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexSubImage1DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexSubImage1DEXT = extproc;

	glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);
}

static void APIENTRY InitTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexSubImage2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexSubImage2DEXT = extproc;

	glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

static void APIENTRY InitCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexImage1DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexImage1DEXT = extproc;

	glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);
}

static void APIENTRY InitCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexImage2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexImage2DEXT = extproc;

	glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);
}

static void APIENTRY InitCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexSubImage1DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexSubImage1DEXT = extproc;

	glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);
}

static void APIENTRY InitCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexSubImage2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexSubImage2DEXT = extproc;

	glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);
}

static void APIENTRY InitCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyTexSubImage3DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyTexSubImage3DEXT = extproc;

	glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

static void APIENTRY InitGetHistogramEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogramEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogramEXT = extproc;

	glGetHistogramEXT(target, reset, format, type, values);
}

static void APIENTRY InitGetHistogramParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogramParameterfvEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogramParameterfvEXT = extproc;

	glGetHistogramParameterfvEXT(target, pname, params);
}

static void APIENTRY InitGetHistogramParameterivEXT (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetHistogramParameterivEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetHistogramParameterivEXT = extproc;

	glGetHistogramParameterivEXT(target, pname, params);
}

static void APIENTRY InitGetMinmaxEXT (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmaxEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmaxEXT = extproc;

	glGetMinmaxEXT(target, reset, format, type, values);
}

static void APIENTRY InitGetMinmaxParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmaxParameterfvEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmaxParameterfvEXT = extproc;

	glGetMinmaxParameterfvEXT(target, pname, params);
}

static void APIENTRY InitGetMinmaxParameterivEXT (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetMinmaxParameterivEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetMinmaxParameterivEXT = extproc;

	glGetMinmaxParameterivEXT(target, pname, params);
}

static void APIENTRY InitHistogramEXT (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glHistogramEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glHistogramEXT = extproc;

	glHistogramEXT(target, width, internalformat, sink);
}

static void APIENTRY InitMinmaxEXT (GLenum target, GLenum internalformat, GLboolean sink)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glMinmaxEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glMinmaxEXT = extproc;

	glMinmaxEXT(target, internalformat, sink);
}

static void APIENTRY InitResetHistogramEXT (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glResetHistogramEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glResetHistogramEXT = extproc;

	glResetHistogramEXT(target);
}

static void APIENTRY InitResetMinmaxEXT (GLenum target)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glResetMinmaxEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glResetMinmaxEXT = extproc;

	glResetMinmaxEXT(target);
}

static void APIENTRY InitConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionFilter1DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionFilter1DEXT = extproc;

	glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);
}

static void APIENTRY InitConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionFilter2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionFilter2DEXT = extproc;

	glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);
}

static void APIENTRY InitConvolutionParameterfEXT (GLenum target, GLenum pname, GLfloat params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameterfEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameterfEXT = extproc;

	glConvolutionParameterfEXT(target, pname, params);
}

static void APIENTRY InitConvolutionParameterfvEXT (GLenum target, GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameterfvEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameterfvEXT = extproc;

	glConvolutionParameterfvEXT(target, pname, params);
}

static void APIENTRY InitConvolutionParameteriEXT (GLenum target, GLenum pname, GLint params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameteriEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameteriEXT = extproc;

	glConvolutionParameteriEXT(target, pname, params);
}

static void APIENTRY InitConvolutionParameterivEXT (GLenum target, GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glConvolutionParameterivEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glConvolutionParameterivEXT = extproc;

	glConvolutionParameterivEXT(target, pname, params);
}

static void APIENTRY InitCopyConvolutionFilter1DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter1DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyConvolutionFilter1DEXT = extproc;

	glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);
}

static void APIENTRY InitCopyConvolutionFilter2DEXT (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyConvolutionFilter2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyConvolutionFilter2DEXT = extproc;

	glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);
}

static void APIENTRY InitGetConvolutionFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *image)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionFilterEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionFilterEXT = extproc;

	glGetConvolutionFilterEXT(target, format, type, image);
}

static void APIENTRY InitGetConvolutionParameterfvEXT (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionParameterfvEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionParameterfvEXT = extproc;

	glGetConvolutionParameterfvEXT(target, pname, params);
}

static void APIENTRY InitGetConvolutionParameterivEXT (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetConvolutionParameterivEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetConvolutionParameterivEXT = extproc;

	glGetConvolutionParameterivEXT(target, pname, params);
}

static void APIENTRY InitGetSeparableFilterEXT (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetSeparableFilterEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetSeparableFilterEXT = extproc;

	glGetSeparableFilterEXT(target, format, type, row, column, span);
}

static void APIENTRY InitSeparableFilter2DEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSeparableFilter2DEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSeparableFilter2DEXT = extproc;

	glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);
}

static void APIENTRY InitColorTableSGI (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTableSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTableSGI = extproc;

	glColorTableSGI(target, internalformat, width, format, type, table);
}

static void APIENTRY InitColorTableParameterfvSGI (GLenum target, GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTableParameterfvSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTableParameterfvSGI = extproc;

	glColorTableParameterfvSGI(target, pname, params);
}

static void APIENTRY InitColorTableParameterivSGI (GLenum target, GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorTableParameterivSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorTableParameterivSGI = extproc;

	glColorTableParameterivSGI(target, pname, params);
}

static void APIENTRY InitCopyColorTableSGI (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glCopyColorTableSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glCopyColorTableSGI = extproc;

	glCopyColorTableSGI(target, internalformat, x, y, width);
}

static void APIENTRY InitGetColorTableSGI (GLenum target, GLenum format, GLenum type, GLvoid *table)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTableSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTableSGI = extproc;

	glGetColorTableSGI(target, format, type, table);
}

static void APIENTRY InitGetColorTableParameterfvSGI (GLenum target, GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTableParameterfvSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTableParameterfvSGI = extproc;

	glGetColorTableParameterfvSGI(target, pname, params);
}

static void APIENTRY InitGetColorTableParameterivSGI (GLenum target, GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetColorTableParameterivSGI");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetColorTableParameterivSGI = extproc;

	glGetColorTableParameterivSGI(target, pname, params);
}

static void APIENTRY InitPixelTexGenSGIX (GLenum mode)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPixelTexGenSGIX");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPixelTexGenSGIX = extproc;

	glPixelTexGenSGIX(mode);
}

static void APIENTRY InitPixelTexGenParameteriSGIS (GLenum pname, GLint param)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPixelTexGenParameteriSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPixelTexGenParameteriSGIS = extproc;

	glPixelTexGenParameteriSGIS(pname, param);
}

static void APIENTRY InitPixelTexGenParameterivSGIS (GLenum pname, const GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPixelTexGenParameterivSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPixelTexGenParameterivSGIS = extproc;

	glPixelTexGenParameterivSGIS(pname, params);
}

static void APIENTRY InitPixelTexGenParameterfSGIS (GLenum pname, GLfloat param)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPixelTexGenParameterfSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPixelTexGenParameterfSGIS = extproc;

	glPixelTexGenParameterfSGIS(pname, param);
}

static void APIENTRY InitPixelTexGenParameterfvSGIS (GLenum pname, const GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPixelTexGenParameterfvSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPixelTexGenParameterfvSGIS = extproc;

	glPixelTexGenParameterfvSGIS(pname, params);
}

static void APIENTRY InitGetPixelTexGenParameterivSGIS (GLenum pname, GLint *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetPixelTexGenParameterivSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetPixelTexGenParameterivSGIS = extproc;

	glGetPixelTexGenParameterivSGIS(pname, params);
}

static void APIENTRY InitGetPixelTexGenParameterfvSGIS (GLenum pname, GLfloat *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetPixelTexGenParameterfvSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetPixelTexGenParameterfvSGIS = extproc;

	glGetPixelTexGenParameterfvSGIS(pname, params);
}

static void APIENTRY InitTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexImage4DSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexImage4DSGIS = extproc;

	glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
}

static void APIENTRY InitTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glTexSubImage4DSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glTexSubImage4DSGIS = extproc;

	glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
}

static GLboolean APIENTRY InitAreTexturesResidentEXT (GLsizei n, const GLuint *textures, GLboolean *residences)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glAreTexturesResidentEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glAreTexturesResidentEXT = extproc;

	return glAreTexturesResidentEXT(n, textures, residences);
}

static void APIENTRY InitBindTextureEXT (GLenum target, GLuint texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glBindTextureEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glBindTextureEXT = extproc;

	glBindTextureEXT(target, texture);
}

static void APIENTRY InitDeleteTexturesEXT (GLsizei n, const GLuint *textures)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDeleteTexturesEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDeleteTexturesEXT = extproc;

	glDeleteTexturesEXT(n, textures);
}

static void APIENTRY InitGenTexturesEXT (GLsizei n, GLuint *textures)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGenTexturesEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGenTexturesEXT = extproc;

	glGenTexturesEXT(n, textures);
}

static GLboolean APIENTRY InitIsTextureEXT (GLuint texture)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIsTextureEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return 0;
	}

	glIsTextureEXT = extproc;

	return glIsTextureEXT(texture);
}

static void APIENTRY InitPrioritizeTexturesEXT (GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glPrioritizeTexturesEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glPrioritizeTexturesEXT = extproc;

	glPrioritizeTexturesEXT(n, textures, priorities);
}

static void APIENTRY InitDetailTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDetailTexFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDetailTexFuncSGIS = extproc;

	glDetailTexFuncSGIS(target, n, points);
}

static void APIENTRY InitGetDetailTexFuncSGIS (GLenum target, GLfloat *points)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetDetailTexFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetDetailTexFuncSGIS = extproc;

	glGetDetailTexFuncSGIS(target, points);
}

static void APIENTRY InitSharpenTexFuncSGIS (GLenum target, GLsizei n, const GLfloat *points)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSharpenTexFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSharpenTexFuncSGIS = extproc;

	glSharpenTexFuncSGIS(target, n, points);
}

static void APIENTRY InitGetSharpenTexFuncSGIS (GLenum target, GLfloat *points)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetSharpenTexFuncSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetSharpenTexFuncSGIS = extproc;

	glGetSharpenTexFuncSGIS(target, points);
}

static void APIENTRY InitSampleMaskSGIS (GLclampf value, GLboolean invert)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSampleMaskSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSampleMaskSGIS = extproc;

	glSampleMaskSGIS(value, invert);
}

static void APIENTRY InitSamplePatternSGIS (GLenum pattern)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glSamplePatternSGIS");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glSamplePatternSGIS = extproc;

	glSamplePatternSGIS(pattern);
}

static void APIENTRY InitArrayElementEXT (GLint i)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glArrayElementEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glArrayElementEXT = extproc;

	glArrayElementEXT(i);
}

static void APIENTRY InitColorPointerEXT (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glColorPointerEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glColorPointerEXT = extproc;

	glColorPointerEXT(size, type, stride, count, pointer);
}

static void APIENTRY InitDrawArraysEXT (GLenum mode, GLint first, GLsizei count)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glDrawArraysEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glDrawArraysEXT = extproc;

	glDrawArraysEXT(mode, first, count);
}

static void APIENTRY InitEdgeFlagPointerEXT (GLsizei stride, GLsizei count, const GLboolean *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glEdgeFlagPointerEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glEdgeFlagPointerEXT = extproc;

	glEdgeFlagPointerEXT(stride, count, pointer);
}

static void APIENTRY InitGetPointervEXT (GLenum pname, GLvoid* *params)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glGetPointervEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glGetPointervEXT = extproc;

	glGetPointervEXT(pname, params);
}

static void APIENTRY InitIndexPointerEXT (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
{
	void *extproc;

	extproc = (void *) wglGetProcAddress("glIndexPointerEXT");

	if (extproc == NULL) {
		_ASSERT(0);
		return;
	}

	glIndexPointerEXT = extproc;

	glIndexPointerEXT(type, stride, count, pointer);
}

static void APIENTRY InitNormalPointerEXT (GLenum type, GLsizei stride, GLsize