#include "swt.h"
#include "gl_structs.h"
#include "gl_stats.h"

#define GL_NATIVE(func) Java_org_eclipse_opengl_GL_##func

#ifndef NO_glAccum
JNIEXPORT void JNICALL GL_NATIVE(glAccum)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glAccum_FUNC);
	glAccum(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glAccum_FUNC);
}
#endif

#ifndef NO_glAlphaFunc
JNIEXPORT void JNICALL GL_NATIVE(glAlphaFunc)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glAlphaFunc_FUNC);
	glAlphaFunc(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glAlphaFunc_FUNC);
}
#endif

#ifndef NO_glAreTexturesResident
JNIEXPORT jboolean JNICALL GL_NATIVE(glAreTexturesResident)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jbooleanArray arg2)
{
	jint *lparg1=NULL;
	jboolean *lparg2=NULL;
	jboolean rc;
	GL_NATIVE_ENTER(env, that, glAreTexturesResident_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
		if (arg2) lparg2 = (*env)->GetBooleanArrayElements(env, arg2, NULL);
	}
	rc = (jboolean)glAreTexturesResident(arg0, (const GLuint *)lparg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseBooleanArrayElements(env, arg2, lparg2, 0);
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glAreTexturesResident_FUNC);
	return rc;
}
#endif

#ifndef NO_glArrayElement
JNIEXPORT void JNICALL GL_NATIVE(glArrayElement)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glArrayElement_FUNC);
	glArrayElement(arg0);
	GL_NATIVE_EXIT(env, that, glArrayElement_FUNC);
}
#endif

#ifndef NO_glBegin
JNIEXPORT void JNICALL GL_NATIVE(glBegin)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glBegin_FUNC);
	glBegin(arg0);
	GL_NATIVE_EXIT(env, that, glBegin_FUNC);
}
#endif

#ifndef NO_glBindTexture
JNIEXPORT void JNICALL GL_NATIVE(glBindTexture)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glBindTexture_FUNC);
	glBindTexture(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glBindTexture_FUNC);
}
#endif

#ifndef NO_glBitmap
JNIEXPORT void JNICALL GL_NATIVE(glBitmap)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jfloat arg5, jbyteArray arg6)
{
	jbyte *lparg6=NULL;
	GL_NATIVE_ENTER(env, that, glBitmap_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
	} else
#endif
	{
		if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
	}
	glBitmap(arg0, arg1, arg2, arg3, arg4, arg5, (const GLubyte *)lparg6);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
	} else
#endif
	{
		if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
	}
	GL_NATIVE_EXIT(env, that, glBitmap_FUNC);
}
#endif

#ifndef NO_glBlendFunc
JNIEXPORT void JNICALL GL_NATIVE(glBlendFunc)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glBlendFunc_FUNC);
	glBlendFunc(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glBlendFunc_FUNC);
}
#endif

#ifndef NO_glCallList
JNIEXPORT void JNICALL GL_NATIVE(glCallList)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glCallList_FUNC);
	glCallList(arg0);
	GL_NATIVE_EXIT(env, that, glCallList_FUNC);
}
#endif

#ifndef NO_glCallLists__II_3B
JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3B)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jbyteArray arg2)
{
	jbyte *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glCallLists__II_3B_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL);
	}
	glCallLists(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glCallLists__II_3B_FUNC);
}
#endif

#ifndef NO_glCallLists__II_3C
JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3C)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jcharArray arg2)
{
	jchar *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glCallLists__II_3C_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetCharArrayElements(env, arg2, NULL);
	}
	glCallLists(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseCharArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glCallLists__II_3C_FUNC);
}
#endif

#ifndef NO_glCallLists__II_3I
JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3I)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glCallLists__II_3I_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glCallLists(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glCallLists__II_3I_FUNC);
}
#endif

#ifndef NO_glClear
JNIEXPORT void JNICALL GL_NATIVE(glClear)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glClear_FUNC);
	glClear(arg0);
	GL_NATIVE_EXIT(env, that, glClear_FUNC);
}
#endif

#ifndef NO_glClearAccum
JNIEXPORT void JNICALL GL_NATIVE(glClearAccum)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glClearAccum_FUNC);
	glClearAccum(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glClearAccum_FUNC);
}
#endif

#ifndef NO_glClearColor
JNIEXPORT void JNICALL GL_NATIVE(glClearColor)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glClearColor_FUNC);
	glClearColor(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glClearColor_FUNC);
}
#endif

#ifndef NO_glClearDepth
JNIEXPORT void JNICALL GL_NATIVE(glClearDepth)
	(JNIEnv *env, jclass that, jdouble arg0)
{
	GL_NATIVE_ENTER(env, that, glClearDepth_FUNC);
	glClearDepth(arg0);
	GL_NATIVE_EXIT(env, that, glClearDepth_FUNC);
}
#endif

#ifndef NO_glClearIndex
JNIEXPORT void JNICALL GL_NATIVE(glClearIndex)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glClearIndex_FUNC);
	glClearIndex(arg0);
	GL_NATIVE_EXIT(env, that, glClearIndex_FUNC);
}
#endif

#ifndef NO_glClearStencil
JNIEXPORT void JNICALL GL_NATIVE(glClearStencil)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glClearStencil_FUNC);
	glClearStencil(arg0);
	GL_NATIVE_EXIT(env, that, glClearStencil_FUNC);
}
#endif

#ifndef NO_glClipPlane
JNIEXPORT void JNICALL GL_NATIVE(glClipPlane)
	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
{
	jdouble *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glClipPlane_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
	}
	glClipPlane(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glClipPlane_FUNC);
}
#endif

#ifndef NO_glColor3b
JNIEXPORT void JNICALL GL_NATIVE(glColor3b)
	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3b_FUNC);
	glColor3b(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3b_FUNC);
}
#endif

#ifndef NO_glColor3bv
JNIEXPORT void JNICALL GL_NATIVE(glColor3bv)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3bv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glColor3bv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3bv_FUNC);
}
#endif

#ifndef NO_glColor3d
JNIEXPORT void JNICALL GL_NATIVE(glColor3d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3d_FUNC);
	glColor3d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3d_FUNC);
}
#endif

#ifndef NO_glColor3dv
JNIEXPORT void JNICALL GL_NATIVE(glColor3dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glColor3dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3dv_FUNC);
}
#endif

#ifndef NO_glColor3f
JNIEXPORT void JNICALL GL_NATIVE(glColor3f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3f_FUNC);
	glColor3f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3f_FUNC);
}
#endif

#ifndef NO_glColor3fv
JNIEXPORT void JNICALL GL_NATIVE(glColor3fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glColor3fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3fv_FUNC);
}
#endif

#ifndef NO_glColor3i
JNIEXPORT void JNICALL GL_NATIVE(glColor3i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3i_FUNC);
	glColor3i(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3i_FUNC);
}
#endif

#ifndef NO_glColor3iv
JNIEXPORT void JNICALL GL_NATIVE(glColor3iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glColor3iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3iv_FUNC);
}
#endif

#ifndef NO_glColor3s
JNIEXPORT void JNICALL GL_NATIVE(glColor3s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3s_FUNC);
	glColor3s(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3s_FUNC);
}
#endif

#ifndef NO_glColor3sv
JNIEXPORT void JNICALL GL_NATIVE(glColor3sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glColor3sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3sv_FUNC);
}
#endif

#ifndef NO_glColor3ub
JNIEXPORT void JNICALL GL_NATIVE(glColor3ub)
	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3ub_FUNC);
	glColor3ub(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3ub_FUNC);
}
#endif

#ifndef NO_glColor3ubv
JNIEXPORT void JNICALL GL_NATIVE(glColor3ubv)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3ubv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glColor3ubv((const GLubyte *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3ubv_FUNC);
}
#endif

#ifndef NO_glColor3ui
JNIEXPORT void JNICALL GL_NATIVE(glColor3ui)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3ui_FUNC);
	glColor3ui(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3ui_FUNC);
}
#endif

#ifndef NO_glColor3uiv
JNIEXPORT void JNICALL GL_NATIVE(glColor3uiv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3uiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glColor3uiv((const GLuint *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3uiv_FUNC);
}
#endif

#ifndef NO_glColor3us
JNIEXPORT void JNICALL GL_NATIVE(glColor3us)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glColor3us_FUNC);
	glColor3us(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glColor3us_FUNC);
}
#endif

#ifndef NO_glColor3usv
JNIEXPORT void JNICALL GL_NATIVE(glColor3usv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor3usv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glColor3usv((const GLushort *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor3usv_FUNC);
}
#endif

#ifndef NO_glColor4b
JNIEXPORT void JNICALL GL_NATIVE(glColor4b)
	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4b_FUNC);
	glColor4b(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4b_FUNC);
}
#endif

#ifndef NO_glColor4bv
JNIEXPORT void JNICALL GL_NATIVE(glColor4bv)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4bv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glColor4bv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4bv_FUNC);
}
#endif

#ifndef NO_glColor4d
JNIEXPORT void JNICALL GL_NATIVE(glColor4d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4d_FUNC);
	glColor4d(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4d_FUNC);
}
#endif

#ifndef NO_glColor4dv
JNIEXPORT void JNICALL GL_NATIVE(glColor4dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glColor4dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4dv_FUNC);
}
#endif

#ifndef NO_glColor4f
JNIEXPORT void JNICALL GL_NATIVE(glColor4f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4f_FUNC);
	glColor4f(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4f_FUNC);
}
#endif

#ifndef NO_glColor4fv
JNIEXPORT void JNICALL GL_NATIVE(glColor4fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glColor4fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4fv_FUNC);
}
#endif

#ifndef NO_glColor4i
JNIEXPORT void JNICALL GL_NATIVE(glColor4i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4i_FUNC);
	glColor4i(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4i_FUNC);
}
#endif

#ifndef NO_glColor4iv
JNIEXPORT void JNICALL GL_NATIVE(glColor4iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glColor4iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4iv_FUNC);
}
#endif

#ifndef NO_glColor4s
JNIEXPORT void JNICALL GL_NATIVE(glColor4s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4s_FUNC);
	glColor4s(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4s_FUNC);
}
#endif

#ifndef NO_glColor4ub
JNIEXPORT void JNICALL GL_NATIVE(glColor4ub)
	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4ub_FUNC);
	glColor4ub(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4ub_FUNC);
}
#endif

#ifndef NO_glColor4ubv
JNIEXPORT void JNICALL GL_NATIVE(glColor4ubv)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4ubv_FUNC);
	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	glColor4ubv((const GLubyte *)lparg0);
	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	GL_NATIVE_EXIT(env, that, glColor4ubv_FUNC);
}
#endif

#ifndef NO_glColor4ui
JNIEXPORT void JNICALL GL_NATIVE(glColor4ui)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4ui_FUNC);
	glColor4ui(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4ui_FUNC);
}
#endif

#ifndef NO_glColor4uiv
JNIEXPORT void JNICALL GL_NATIVE(glColor4uiv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4uiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glColor4uiv((const GLuint *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4uiv_FUNC);
}
#endif

#ifndef NO_glColor4us
JNIEXPORT void JNICALL GL_NATIVE(glColor4us)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glColor4us_FUNC);
	glColor4us(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColor4us_FUNC);
}
#endif

#ifndef NO_glColor4usv
JNIEXPORT void JNICALL GL_NATIVE(glColor4usv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glColor4usv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glColor4usv((const GLushort *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glColor4usv_FUNC);
}
#endif

#ifndef NO_glColorMask
JNIEXPORT void JNICALL GL_NATIVE(glColorMask)
	(JNIEnv *env, jclass that, jboolean arg0, jboolean arg1, jboolean arg2, jboolean arg3)
{
	GL_NATIVE_ENTER(env, that, glColorMask_FUNC);
	glColorMask(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glColorMask_FUNC);
}
#endif

#ifndef NO_glColorMaterial
JNIEXPORT void JNICALL GL_NATIVE(glColorMaterial)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glColorMaterial_FUNC);
	glColorMaterial(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glColorMaterial_FUNC);
}
#endif

#ifndef NO_glColorPointer
JNIEXPORT void JNICALL GL_NATIVE(glColorPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glColorPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
	}
	glColorPointer(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glColorPointer_FUNC);
}
#endif

#ifndef NO_glCopyPixels
JNIEXPORT void JNICALL GL_NATIVE(glCopyPixels)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
{
	GL_NATIVE_ENTER(env, that, glCopyPixels_FUNC);
	glCopyPixels(arg0, arg1, arg2, arg3, arg4);
	GL_NATIVE_EXIT(env, that, glCopyPixels_FUNC);
}
#endif

#ifndef NO_glCopyTexImage1D
JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage1D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
{
	GL_NATIVE_ENTER(env, that, glCopyTexImage1D_FUNC);
	glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
	GL_NATIVE_EXIT(env, that, glCopyTexImage1D_FUNC);
}
#endif

#ifndef NO_glCopyTexImage2D
JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage2D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
{
	GL_NATIVE_ENTER(env, that, glCopyTexImage2D_FUNC);
	glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
	GL_NATIVE_EXIT(env, that, glCopyTexImage2D_FUNC);
}
#endif

#ifndef NO_glCopyTexSubImage1D
JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage1D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
{
	GL_NATIVE_ENTER(env, that, glCopyTexSubImage1D_FUNC);
	glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5);
	GL_NATIVE_EXIT(env, that, glCopyTexSubImage1D_FUNC);
}
#endif

#ifndef NO_glCopyTexSubImage2D
JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage2D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
{
	GL_NATIVE_ENTER(env, that, glCopyTexSubImage2D_FUNC);
	glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
	GL_NATIVE_EXIT(env, that, glCopyTexSubImage2D_FUNC);
}
#endif

#ifndef NO_glCullFace
JNIEXPORT void JNICALL GL_NATIVE(glCullFace)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glCullFace_FUNC);
	glCullFace(arg0);
	GL_NATIVE_EXIT(env, that, glCullFace_FUNC);
}
#endif

#ifndef NO_glDeleteLists
JNIEXPORT void JNICALL GL_NATIVE(glDeleteLists)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glDeleteLists_FUNC);
	glDeleteLists(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glDeleteLists_FUNC);
}
#endif

#ifndef NO_glDeleteTextures
JNIEXPORT void JNICALL GL_NATIVE(glDeleteTextures)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glDeleteTextures_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glDeleteTextures(arg0, (const GLuint *)lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glDeleteTextures_FUNC);
}
#endif

#ifndef NO_glDepthFunc
JNIEXPORT void JNICALL GL_NATIVE(glDepthFunc)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glDepthFunc_FUNC);
	glDepthFunc(arg0);
	GL_NATIVE_EXIT(env, that, glDepthFunc_FUNC);
}
#endif

#ifndef NO_glDepthMask
JNIEXPORT void JNICALL GL_NATIVE(glDepthMask)
	(JNIEnv *env, jclass that, jboolean arg0)
{
	GL_NATIVE_ENTER(env, that, glDepthMask_FUNC);
	glDepthMask(arg0);
	GL_NATIVE_EXIT(env, that, glDepthMask_FUNC);
}
#endif

#ifndef NO_glDepthRange
JNIEXPORT void JNICALL GL_NATIVE(glDepthRange)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
{
	GL_NATIVE_ENTER(env, that, glDepthRange_FUNC);
	glDepthRange(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glDepthRange_FUNC);
}
#endif

#ifndef NO_glDisable
JNIEXPORT void JNICALL GL_NATIVE(glDisable)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glDisable_FUNC);
	glDisable(arg0);
	GL_NATIVE_EXIT(env, that, glDisable_FUNC);
}
#endif

#ifndef NO_glDisableClientState
JNIEXPORT void JNICALL GL_NATIVE(glDisableClientState)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glDisableClientState_FUNC);
	glDisableClientState(arg0);
	GL_NATIVE_EXIT(env, that, glDisableClientState_FUNC);
}
#endif

#ifndef NO_glDrawArrays
JNIEXPORT void JNICALL GL_NATIVE(glDrawArrays)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glDrawArrays_FUNC);
	glDrawArrays(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glDrawArrays_FUNC);
}
#endif

#ifndef NO_glDrawBuffer
JNIEXPORT void JNICALL GL_NATIVE(glDrawBuffer)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glDrawBuffer_FUNC);
	glDrawBuffer(arg0);
	GL_NATIVE_EXIT(env, that, glDrawBuffer_FUNC);
}
#endif

#ifndef NO_glDrawElements
JNIEXPORT void JNICALL GL_NATIVE(glDrawElements)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glDrawElements_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
	}
	glDrawElements(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glDrawElements_FUNC);
}
#endif

#ifndef NO_glDrawPixels
JNIEXPORT void JNICALL GL_NATIVE(glDrawPixels)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
{
	jint *lparg4=NULL;
	GL_NATIVE_ENTER(env, that, glDrawPixels_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
	} else
#endif
	{
		if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
	}
	glDrawPixels(arg0, arg1, arg2, arg3, lparg4);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
	} else
#endif
	{
		if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	}
	GL_NATIVE_EXIT(env, that, glDrawPixels_FUNC);
}
#endif

#ifndef NO_glEdgeFlag
JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlag)
	(JNIEnv *env, jclass that, jboolean arg0)
{
	GL_NATIVE_ENTER(env, that, glEdgeFlag_FUNC);
	glEdgeFlag(arg0);
	GL_NATIVE_EXIT(env, that, glEdgeFlag_FUNC);
}
#endif

#ifndef NO_glEdgeFlagPointer
JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagPointer)
	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
{
	jboolean *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glEdgeFlagPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);
	}
	glEdgeFlagPointer(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glEdgeFlagPointer_FUNC);
}
#endif

#ifndef NO_glEdgeFlagv
JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagv)
	(JNIEnv *env, jclass that, jbooleanArray arg0)
{
	jboolean *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glEdgeFlagv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetBooleanArrayElements(env, arg0, NULL);
	}
	glEdgeFlagv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseBooleanArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glEdgeFlagv_FUNC);
}
#endif

#ifndef NO_glEnable
JNIEXPORT void JNICALL GL_NATIVE(glEnable)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glEnable_FUNC);
	glEnable(arg0);
	GL_NATIVE_EXIT(env, that, glEnable_FUNC);
}
#endif

#ifndef NO_glEnableClientState
JNIEXPORT void JNICALL GL_NATIVE(glEnableClientState)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glEnableClientState_FUNC);
	glEnableClientState(arg0);
	GL_NATIVE_EXIT(env, that, glEnableClientState_FUNC);
}
#endif

#ifndef NO_glEnd
JNIEXPORT void JNICALL GL_NATIVE(glEnd)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glEnd_FUNC);
	glEnd();
	GL_NATIVE_EXIT(env, that, glEnd_FUNC);
}
#endif

#ifndef NO_glEndList
JNIEXPORT void JNICALL GL_NATIVE(glEndList)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glEndList_FUNC);
	glEndList();
	GL_NATIVE_EXIT(env, that, glEndList_FUNC);
}
#endif

#ifndef NO_glEvalCoord1d
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1d)
	(JNIEnv *env, jclass that, jdouble arg0)
{
	GL_NATIVE_ENTER(env, that, glEvalCoord1d_FUNC);
	glEvalCoord1d(arg0);
	GL_NATIVE_EXIT(env, that, glEvalCoord1d_FUNC);
}
#endif

#ifndef NO_glEvalCoord1dv
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glEvalCoord1dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glEvalCoord1dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glEvalCoord1dv_FUNC);
}
#endif

#ifndef NO_glEvalCoord1f
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1f)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glEvalCoord1f_FUNC);
	glEvalCoord1f(arg0);
	GL_NATIVE_EXIT(env, that, glEvalCoord1f_FUNC);
}
#endif

#ifndef NO_glEvalCoord1fv
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glEvalCoord1fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glEvalCoord1fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glEvalCoord1fv_FUNC);
}
#endif

#ifndef NO_glEvalCoord2d
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
{
	GL_NATIVE_ENTER(env, that, glEvalCoord2d_FUNC);
	glEvalCoord2d(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glEvalCoord2d_FUNC);
}
#endif

#ifndef NO_glEvalCoord2dv
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glEvalCoord2dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glEvalCoord2dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glEvalCoord2dv_FUNC);
}
#endif

#ifndef NO_glEvalCoord2f
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glEvalCoord2f_FUNC);
	glEvalCoord2f(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glEvalCoord2f_FUNC);
}
#endif

#ifndef NO_glEvalCoord2fv
JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glEvalCoord2fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glEvalCoord2fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glEvalCoord2fv_FUNC);
}
#endif

#ifndef NO_glEvalMesh1
JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh1)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glEvalMesh1_FUNC);
	glEvalMesh1(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glEvalMesh1_FUNC);
}
#endif

#ifndef NO_glEvalMesh2
JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh2)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
{
	GL_NATIVE_ENTER(env, that, glEvalMesh2_FUNC);
	glEvalMesh2(arg0, arg1, arg2, arg3, arg4);
	GL_NATIVE_EXIT(env, that, glEvalMesh2_FUNC);
}
#endif

#ifndef NO_glEvalPoint1
JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint1)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glEvalPoint1_FUNC);
	glEvalPoint1(arg0);
	GL_NATIVE_EXIT(env, that, glEvalPoint1_FUNC);
}
#endif

#ifndef NO_glEvalPoint2
JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint2)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glEvalPoint2_FUNC);
	glEvalPoint2(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glEvalPoint2_FUNC);
}
#endif

#ifndef NO_glFeedbackBuffer
JNIEXPORT void JNICALL GL_NATIVE(glFeedbackBuffer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glFeedbackBuffer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glFeedbackBuffer(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glFeedbackBuffer_FUNC);
}
#endif

#ifndef NO_glFinish
JNIEXPORT void JNICALL GL_NATIVE(glFinish)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glFinish_FUNC);
	glFinish();
	GL_NATIVE_EXIT(env, that, glFinish_FUNC);
}
#endif

#ifndef NO_glFlush
JNIEXPORT void JNICALL GL_NATIVE(glFlush)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glFlush_FUNC);
	glFlush();
	GL_NATIVE_EXIT(env, that, glFlush_FUNC);
}
#endif

#ifndef NO_glFogf
JNIEXPORT void JNICALL GL_NATIVE(glFogf)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glFogf_FUNC);
	glFogf(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glFogf_FUNC);
}
#endif

#ifndef NO_glFogfv
JNIEXPORT void JNICALL GL_NATIVE(glFogfv)
	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
{
	jfloat *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glFogfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
	}
	glFogfv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glFogfv_FUNC);
}
#endif

#ifndef NO_glFogi
JNIEXPORT void JNICALL GL_NATIVE(glFogi)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glFogi_FUNC);
	glFogi(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glFogi_FUNC);
}
#endif

#ifndef NO_glFogiv
JNIEXPORT void JNICALL GL_NATIVE(glFogiv)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glFogiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glFogiv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glFogiv_FUNC);
}
#endif

#ifndef NO_glFrontFace
JNIEXPORT void JNICALL GL_NATIVE(glFrontFace)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glFrontFace_FUNC);
	glFrontFace(arg0);
	GL_NATIVE_EXIT(env, that, glFrontFace_FUNC);
}
#endif

#ifndef NO_glFrustum
JNIEXPORT void JNICALL GL_NATIVE(glFrustum)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
{
	GL_NATIVE_ENTER(env, that, glFrustum_FUNC);
	glFrustum(arg0, arg1, arg2, arg3, arg4, arg5);
	GL_NATIVE_EXIT(env, that, glFrustum_FUNC);
}
#endif

#ifndef NO_glGenLists
JNIEXPORT jint JNICALL GL_NATIVE(glGenLists)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc;
	GL_NATIVE_ENTER(env, that, glGenLists_FUNC);
	rc = (jint)glGenLists(arg0);
	GL_NATIVE_EXIT(env, that, glGenLists_FUNC);
	return rc;
}
#endif

#ifndef NO_glGenTextures
JNIEXPORT void JNICALL GL_NATIVE(glGenTextures)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGenTextures_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glGenTextures(arg0, (GLuint *)lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGenTextures_FUNC);
}
#endif

#ifndef NO_glGetBooleanv
JNIEXPORT void JNICALL GL_NATIVE(glGetBooleanv)
	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
{
	jboolean *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetBooleanv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);
	}
	glGetBooleanv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetBooleanv_FUNC);
}
#endif

#ifndef NO_glGetClipPlane
JNIEXPORT void JNICALL GL_NATIVE(glGetClipPlane)
	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
{
	jdouble *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetClipPlane_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
	}
	glGetClipPlane(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetClipPlane_FUNC);
}
#endif

#ifndef NO_glGetDoublev
JNIEXPORT void JNICALL GL_NATIVE(glGetDoublev)
	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
{
	jdouble *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetDoublev_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
	}
	glGetDoublev(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetDoublev_FUNC);
}
#endif

#ifndef NO_glGetError
JNIEXPORT jint JNICALL GL_NATIVE(glGetError)
	(JNIEnv *env, jclass that)
{
	jint rc;
	GL_NATIVE_ENTER(env, that, glGetError_FUNC);
	rc = (jint)glGetError();
	GL_NATIVE_EXIT(env, that, glGetError_FUNC);
	return rc;
}
#endif

#ifndef NO_glGetFloatv
JNIEXPORT void JNICALL GL_NATIVE(glGetFloatv)
	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
{
	jfloat *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetFloatv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
	}
	glGetFloatv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetFloatv_FUNC);
}
#endif

#ifndef NO_glGetIntegerv
JNIEXPORT void JNICALL GL_NATIVE(glGetIntegerv)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetIntegerv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glGetIntegerv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetIntegerv_FUNC);
}
#endif

#ifndef NO_glGetLightfv
JNIEXPORT void JNICALL GL_NATIVE(glGetLightfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetLightfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetLightfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetLightfv_FUNC);
}
#endif

#ifndef NO_glGetLightiv
JNIEXPORT void JNICALL GL_NATIVE(glGetLightiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetLightiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetLightiv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetLightiv_FUNC);
}
#endif

#ifndef NO_glGetMapdv
JNIEXPORT void JNICALL GL_NATIVE(glGetMapdv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
{
	jdouble *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetMapdv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
	}
	glGetMapdv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetMapdv_FUNC);
}
#endif

#ifndef NO_glGetMapfv
JNIEXPORT void JNICALL GL_NATIVE(glGetMapfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetMapfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetMapfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetMapfv_FUNC);
}
#endif

#ifndef NO_glGetMapiv
JNIEXPORT void JNICALL GL_NATIVE(glGetMapiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetMapiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetMapiv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetMapiv_FUNC);
}
#endif

#ifndef NO_glGetMaterialfv
JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetMaterialfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetMaterialfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetMaterialfv_FUNC);
}
#endif

#ifndef NO_glGetMaterialiv
JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetMaterialiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetMaterialiv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetMaterialiv_FUNC);
}
#endif

#ifndef NO_glGetPixelMapfv
JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapfv)
	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
{
	jfloat *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetPixelMapfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
	}
	glGetPixelMapfv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetPixelMapfv_FUNC);
}
#endif

#ifndef NO_glGetPixelMapuiv
JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapuiv)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetPixelMapuiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glGetPixelMapuiv(arg0, (GLuint *)lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetPixelMapuiv_FUNC);
}
#endif

#ifndef NO_glGetPixelMapusv
JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapusv)
	(JNIEnv *env, jclass that, jint arg0, jshortArray arg1)
{
	jshort *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetPixelMapusv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);
	}
	glGetPixelMapusv(arg0, (GLushort *)lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetPixelMapusv_FUNC);
}
#endif

#ifndef NO_glGetPointerv
JNIEXPORT void JNICALL GL_NATIVE(glGetPointerv)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glGetPointerv_FUNC);
	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	glGetPointerv(arg0, (GLvoid **)lparg1);
	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	GL_NATIVE_EXIT(env, that, glGetPointerv_FUNC);
}
#endif

#ifndef NO_glGetPolygonStipple
JNIEXPORT void JNICALL GL_NATIVE(glGetPolygonStipple)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glGetPolygonStipple_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glGetPolygonStipple((GLubyte *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetPolygonStipple_FUNC);
}
#endif

#ifndef NO_glGetString
JNIEXPORT jint JNICALL GL_NATIVE(glGetString)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc;
	GL_NATIVE_ENTER(env, that, glGetString_FUNC);
	rc = (jint)glGetString(arg0);
	GL_NATIVE_EXIT(env, that, glGetString_FUNC);
	return rc;
}
#endif

#ifndef NO_glGetTexEnvfv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnvfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexEnvfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetTexEnvfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexEnvfv_FUNC);
}
#endif

#ifndef NO_glGetTexEnviv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnviv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexEnviv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetTexEnviv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexEnviv_FUNC);
}
#endif

#ifndef NO_glGetTexGendv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexGendv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
{
	jdouble *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexGendv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
	}
	glGetTexGendv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexGendv_FUNC);
}
#endif

#ifndef NO_glGetTexGenfv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexGenfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexGenfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetTexGenfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexGenfv_FUNC);
}
#endif

#ifndef NO_glGetTexGeniv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexGeniv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexGeniv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetTexGeniv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexGeniv_FUNC);
}
#endif

#ifndef NO_glGetTexImage
JNIEXPORT void JNICALL GL_NATIVE(glGetTexImage)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
{
	jint *lparg4=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexImage_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg4) lparg4 = (*env)->GetPrimitiveArrayCritical(env, arg4, NULL);
	} else
#endif
	{
		if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
	}
	glGetTexImage(arg0, arg1, arg2, arg3, lparg4);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg4) (*env)->ReleasePrimitiveArrayCritical(env, arg4, lparg4, 0);
	} else
#endif
	{
		if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexImage_FUNC);
}
#endif

#ifndef NO_glGetTexLevelParameterfv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameterfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jfloatArray arg3)
{
	jfloat *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexLevelParameterfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetFloatArrayElements(env, arg3, NULL);
	}
	glGetTexLevelParameterfv(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseFloatArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexLevelParameterfv_FUNC);
}
#endif

#ifndef NO_glGetTexLevelParameteriv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameteriv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexLevelParameteriv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
	}
	glGetTexLevelParameteriv(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexLevelParameteriv_FUNC);
}
#endif

#ifndef NO_glGetTexParameterfv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameterfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexParameterfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glGetTexParameterfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexParameterfv_FUNC);
}
#endif

#ifndef NO_glGetTexParameteriv
JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameteriv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glGetTexParameteriv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glGetTexParameteriv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glGetTexParameteriv_FUNC);
}
#endif

#ifndef NO_glHint
JNIEXPORT void JNICALL GL_NATIVE(glHint)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glHint_FUNC);
	glHint(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glHint_FUNC);
}
#endif

#ifndef NO_glIndexMask
JNIEXPORT void JNICALL GL_NATIVE(glIndexMask)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glIndexMask_FUNC);
	glIndexMask(arg0);
	GL_NATIVE_EXIT(env, that, glIndexMask_FUNC);
}
#endif

#ifndef NO_glIndexPointer
JNIEXPORT void JNICALL GL_NATIVE(glIndexPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glIndexPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glIndexPointer(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glIndexPointer_FUNC);
}
#endif

#ifndef NO_glIndexd
JNIEXPORT void JNICALL GL_NATIVE(glIndexd)
	(JNIEnv *env, jclass that, jdouble arg0)
{
	GL_NATIVE_ENTER(env, that, glIndexd_FUNC);
	glIndexd(arg0);
	GL_NATIVE_EXIT(env, that, glIndexd_FUNC);
}
#endif

#ifndef NO_glIndexdv
JNIEXPORT void JNICALL GL_NATIVE(glIndexdv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glIndexdv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glIndexdv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glIndexdv_FUNC);
}
#endif

#ifndef NO_glIndexf
JNIEXPORT void JNICALL GL_NATIVE(glIndexf)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glIndexf_FUNC);
	glIndexf(arg0);
	GL_NATIVE_EXIT(env, that, glIndexf_FUNC);
}
#endif

#ifndef NO_glIndexfv
JNIEXPORT void JNICALL GL_NATIVE(glIndexfv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glIndexfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glIndexfv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glIndexfv_FUNC);
}
#endif

#ifndef NO_glIndexi
JNIEXPORT void JNICALL GL_NATIVE(glIndexi)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glIndexi_FUNC);
	glIndexi(arg0);
	GL_NATIVE_EXIT(env, that, glIndexi_FUNC);
}
#endif

#ifndef NO_glIndexiv
JNIEXPORT void JNICALL GL_NATIVE(glIndexiv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glIndexiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glIndexiv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glIndexiv_FUNC);
}
#endif

#ifndef NO_glIndexs
JNIEXPORT void JNICALL GL_NATIVE(glIndexs)
	(JNIEnv *env, jclass that, jshort arg0)
{
	GL_NATIVE_ENTER(env, that, glIndexs_FUNC);
	glIndexs(arg0);
	GL_NATIVE_EXIT(env, that, glIndexs_FUNC);
}
#endif

#ifndef NO_glIndexsv
JNIEXPORT void JNICALL GL_NATIVE(glIndexsv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glIndexsv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glIndexsv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glIndexsv_FUNC);
}
#endif

#ifndef NO_glInitNames
JNIEXPORT void JNICALL GL_NATIVE(glInitNames)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glInitNames_FUNC);
	glInitNames();
	GL_NATIVE_EXIT(env, that, glInitNames_FUNC);
}
#endif

#ifndef NO_glInterleavedArrays
JNIEXPORT void JNICALL GL_NATIVE(glInterleavedArrays)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glInterleavedArrays_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glInterleavedArrays(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glInterleavedArrays_FUNC);
}
#endif

#ifndef NO_glIsEnabled
JNIEXPORT jboolean JNICALL GL_NATIVE(glIsEnabled)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc;
	GL_NATIVE_ENTER(env, that, glIsEnabled_FUNC);
	rc = (jboolean)glIsEnabled(arg0);
	GL_NATIVE_EXIT(env, that, glIsEnabled_FUNC);
	return rc;
}
#endif

#ifndef NO_glIsList
JNIEXPORT jboolean JNICALL GL_NATIVE(glIsList)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc;
	GL_NATIVE_ENTER(env, that, glIsList_FUNC);
	rc = (jboolean)glIsList(arg0);
	GL_NATIVE_EXIT(env, that, glIsList_FUNC);
	return rc;
}
#endif

#ifndef NO_glIsTexture
JNIEXPORT jboolean JNICALL GL_NATIVE(glIsTexture)
	(JNIEnv *env, jclass that, jint arg0)
{
	jboolean rc;
	GL_NATIVE_ENTER(env, that, glIsTexture_FUNC);
	rc = (jboolean)glIsTexture(arg0);
	GL_NATIVE_EXIT(env, that, glIsTexture_FUNC);
	return rc;
}
#endif

#ifndef NO_glLightModelf
JNIEXPORT void JNICALL GL_NATIVE(glLightModelf)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glLightModelf_FUNC);
	glLightModelf(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glLightModelf_FUNC);
}
#endif

#ifndef NO_glLightModelfv
JNIEXPORT void JNICALL GL_NATIVE(glLightModelfv)
	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
{
	jfloat *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glLightModelfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
	}
	glLightModelfv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glLightModelfv_FUNC);
}
#endif

#ifndef NO_glLightModeli
JNIEXPORT void JNICALL GL_NATIVE(glLightModeli)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glLightModeli_FUNC);
	glLightModeli(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glLightModeli_FUNC);
}
#endif

#ifndef NO_glLightModeliv
JNIEXPORT void JNICALL GL_NATIVE(glLightModeliv)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
{
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glLightModeliv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glLightModeliv(arg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glLightModeliv_FUNC);
}
#endif

#ifndef NO_glLightf
JNIEXPORT void JNICALL GL_NATIVE(glLightf)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glLightf_FUNC);
	glLightf(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glLightf_FUNC);
}
#endif

#ifndef NO_glLightfv
JNIEXPORT void JNICALL GL_NATIVE(glLightfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glLightfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glLightfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glLightfv_FUNC);
}
#endif

#ifndef NO_glLighti
JNIEXPORT void JNICALL GL_NATIVE(glLighti)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glLighti_FUNC);
	glLighti(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glLighti_FUNC);
}
#endif

#ifndef NO_glLightiv
JNIEXPORT void JNICALL GL_NATIVE(glLightiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glLightiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glLightiv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glLightiv_FUNC);
}
#endif

#ifndef NO_glLineStipple
JNIEXPORT void JNICALL GL_NATIVE(glLineStipple)
	(JNIEnv *env, jclass that, jint arg0, jshort arg1)
{
	GL_NATIVE_ENTER(env, that, glLineStipple_FUNC);
	glLineStipple(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glLineStipple_FUNC);
}
#endif

#ifndef NO_glLineWidth
JNIEXPORT void JNICALL GL_NATIVE(glLineWidth)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glLineWidth_FUNC);
	glLineWidth(arg0);
	GL_NATIVE_EXIT(env, that, glLineWidth_FUNC);
}
#endif

#ifndef NO_glListBase
JNIEXPORT void JNICALL GL_NATIVE(glListBase)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glListBase_FUNC);
	glListBase(arg0);
	GL_NATIVE_EXIT(env, that, glListBase_FUNC);
}
#endif

#ifndef NO_glLoadIdentity
JNIEXPORT void JNICALL GL_NATIVE(glLoadIdentity)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glLoadIdentity_FUNC);
	glLoadIdentity();
	GL_NATIVE_EXIT(env, that, glLoadIdentity_FUNC);
}
#endif

#ifndef NO_glLoadMatrixd
JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixd)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glLoadMatrixd_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glLoadMatrixd(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glLoadMatrixd_FUNC);
}
#endif

#ifndef NO_glLoadMatrixf
JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixf)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glLoadMatrixf_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glLoadMatrixf(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glLoadMatrixf_FUNC);
}
#endif

#ifndef NO_glLoadName
JNIEXPORT void JNICALL GL_NATIVE(glLoadName)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glLoadName_FUNC);
	glLoadName(arg0);
	GL_NATIVE_EXIT(env, that, glLoadName_FUNC);
}
#endif

#ifndef NO_glLogicOp
JNIEXPORT void JNICALL GL_NATIVE(glLogicOp)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glLogicOp_FUNC);
	glLogicOp(arg0);
	GL_NATIVE_EXIT(env, that, glLogicOp_FUNC);
}
#endif

#ifndef NO_glMap1d
JNIEXPORT void JNICALL GL_NATIVE(glMap1d)
	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdoubleArray arg5)
{
	jdouble *lparg5=NULL;
	GL_NATIVE_ENTER(env, that, glMap1d_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
	} else
#endif
	{
		if (arg5) lparg5 = (*env)->GetDoubleArrayElements(env, arg5, NULL);
	}
	glMap1d(arg0, arg1, arg2, arg3, arg4, lparg5);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
	} else
#endif
	{
		if (arg5) (*env)->ReleaseDoubleArrayElements(env, arg5, lparg5, 0);
	}
	GL_NATIVE_EXIT(env, that, glMap1d_FUNC);
}
#endif

#ifndef NO_glMap1f
JNIEXPORT void JNICALL GL_NATIVE(glMap1f)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloatArray arg5)
{
	jfloat *lparg5=NULL;
	GL_NATIVE_ENTER(env, that, glMap1f_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg5) lparg5 = (*env)->GetPrimitiveArrayCritical(env, arg5, NULL);
	} else
#endif
	{
		if (arg5) lparg5 = (*env)->GetFloatArrayElements(env, arg5, NULL);
	}
	glMap1f(arg0, arg1, arg2, arg3, arg4, lparg5);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg5) (*env)->ReleasePrimitiveArrayCritical(env, arg5, lparg5, 0);
	} else
#endif
	{
		if (arg5) (*env)->ReleaseFloatArrayElements(env, arg5, lparg5, 0);
	}
	GL_NATIVE_EXIT(env, that, glMap1f_FUNC);
}
#endif

#ifndef NO_glMap2d
JNIEXPORT void JNICALL GL_NATIVE(glMap2d)
	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6, jint arg7, jint arg8, jdoubleArray arg9)
{
	jdouble *lparg9=NULL;
	GL_NATIVE_ENTER(env, that, glMap2d_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg9) lparg9 = (*env)->GetPrimitiveArrayCritical(env, arg9, NULL);
	} else
#endif
	{
		if (arg9) lparg9 = (*env)->GetDoubleArrayElements(env, arg9, NULL);
	}
	glMap2d(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, lparg9);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg9) (*env)->ReleasePrimitiveArrayCritical(env, arg9, lparg9, 0);
	} else
#endif
	{
		if (arg9) (*env)->ReleaseDoubleArrayElements(env, arg9, lparg9, 0);
	}
	GL_NATIVE_EXIT(env, that, glMap2d_FUNC);
}
#endif

#ifndef NO_glMap2f
JNIEXPORT void JNICALL GL_NATIVE(glMap2f)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloat arg5, jfloat arg6, jint arg7, jint arg8, jfloatArray arg9)
{
	jfloat *lparg9=NULL;
	GL_NATIVE_ENTER(env, that, glMap2f_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg9) lparg9 = (*env)->GetPrimitiveArrayCritical(env, arg9, NULL);
	} else
#endif
	{
		if (arg9) lparg9 = (*env)->GetFloatArrayElements(env, arg9, NULL);
	}
	glMap2f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, lparg9);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg9) (*env)->ReleasePrimitiveArrayCritical(env, arg9, lparg9, 0);
	} else
#endif
	{
		if (arg9) (*env)->ReleaseFloatArrayElements(env, arg9, lparg9, 0);
	}
	GL_NATIVE_EXIT(env, that, glMap2f_FUNC);
}
#endif

#ifndef NO_glMapGrid1d
JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1d)
	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glMapGrid1d_FUNC);
	glMapGrid1d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glMapGrid1d_FUNC);
}
#endif

#ifndef NO_glMapGrid1f
JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1f)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glMapGrid1f_FUNC);
	glMapGrid1f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glMapGrid1f_FUNC);
}
#endif

#ifndef NO_glMapGrid2d
JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2d)
	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jdouble arg4, jdouble arg5)
{
	GL_NATIVE_ENTER(env, that, glMapGrid2d_FUNC);
	glMapGrid2d(arg0, arg1, arg2, arg3, arg4, arg5);
	GL_NATIVE_EXIT(env, that, glMapGrid2d_FUNC);
}
#endif

#ifndef NO_glMapGrid2f
JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2f)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jfloat arg4, jfloat arg5)
{
	GL_NATIVE_ENTER(env, that, glMapGrid2f_FUNC);
	glMapGrid2f(arg0, arg1, arg2, arg3, arg4, arg5);
	GL_NATIVE_EXIT(env, that, glMapGrid2f_FUNC);
}
#endif

#ifndef NO_glMaterialf
JNIEXPORT void JNICALL GL_NATIVE(glMaterialf)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glMaterialf_FUNC);
	glMaterialf(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glMaterialf_FUNC);
}
#endif

#ifndef NO_glMaterialfv
JNIEXPORT void JNICALL GL_NATIVE(glMaterialfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glMaterialfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glMaterialfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glMaterialfv_FUNC);
}
#endif

#ifndef NO_glMateriali
JNIEXPORT void JNICALL GL_NATIVE(glMateriali)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glMateriali_FUNC);
	glMateriali(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glMateriali_FUNC);
}
#endif

#ifndef NO_glMaterialiv
JNIEXPORT void JNICALL GL_NATIVE(glMaterialiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glMaterialiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glMaterialiv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glMaterialiv_FUNC);
}
#endif

#ifndef NO_glMatrixMode
JNIEXPORT void JNICALL GL_NATIVE(glMatrixMode)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glMatrixMode_FUNC);
	glMatrixMode(arg0);
	GL_NATIVE_EXIT(env, that, glMatrixMode_FUNC);
}
#endif

#ifndef NO_glMultMatrixd
JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixd)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glMultMatrixd_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glMultMatrixd(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glMultMatrixd_FUNC);
}
#endif

#ifndef NO_glMultMatrixf
JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixf)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glMultMatrixf_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glMultMatrixf(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glMultMatrixf_FUNC);
}
#endif

#ifndef NO_glNewList
JNIEXPORT void JNICALL GL_NATIVE(glNewList)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glNewList_FUNC);
	glNewList(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glNewList_FUNC);
}
#endif

#ifndef NO_glNormal3b
JNIEXPORT void JNICALL GL_NATIVE(glNormal3b)
	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
{
	GL_NATIVE_ENTER(env, that, glNormal3b_FUNC);
	glNormal3b(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glNormal3b_FUNC);
}
#endif

#ifndef NO_glNormal3bv
JNIEXPORT void JNICALL GL_NATIVE(glNormal3bv)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glNormal3bv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glNormal3bv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormal3bv_FUNC);
}
#endif

#ifndef NO_glNormal3d
JNIEXPORT void JNICALL GL_NATIVE(glNormal3d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glNormal3d_FUNC);
	glNormal3d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glNormal3d_FUNC);
}
#endif

#ifndef NO_glNormal3dv
JNIEXPORT void JNICALL GL_NATIVE(glNormal3dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glNormal3dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glNormal3dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormal3dv_FUNC);
}
#endif

#ifndef NO_glNormal3f
JNIEXPORT void JNICALL GL_NATIVE(glNormal3f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glNormal3f_FUNC);
	glNormal3f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glNormal3f_FUNC);
}
#endif

#ifndef NO_glNormal3fv
JNIEXPORT void JNICALL GL_NATIVE(glNormal3fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glNormal3fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glNormal3fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormal3fv_FUNC);
}
#endif

#ifndef NO_glNormal3i
JNIEXPORT void JNICALL GL_NATIVE(glNormal3i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glNormal3i_FUNC);
	glNormal3i(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glNormal3i_FUNC);
}
#endif

#ifndef NO_glNormal3iv
JNIEXPORT void JNICALL GL_NATIVE(glNormal3iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glNormal3iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glNormal3iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormal3iv_FUNC);
}
#endif

#ifndef NO_glNormal3s
JNIEXPORT void JNICALL GL_NATIVE(glNormal3s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glNormal3s_FUNC);
	glNormal3s(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glNormal3s_FUNC);
}
#endif

#ifndef NO_glNormal3sv
JNIEXPORT void JNICALL GL_NATIVE(glNormal3sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glNormal3sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glNormal3sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormal3sv_FUNC);
}
#endif

#ifndef NO_glNormalPointer
JNIEXPORT void JNICALL GL_NATIVE(glNormalPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glNormalPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glNormalPointer(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glNormalPointer_FUNC);
}
#endif

#ifndef NO_glOrtho
JNIEXPORT void JNICALL GL_NATIVE(glOrtho)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
{
	GL_NATIVE_ENTER(env, that, glOrtho_FUNC);
	glOrtho(arg0, arg1, arg2, arg3, arg4, arg5);
	GL_NATIVE_EXIT(env, that, glOrtho_FUNC);
}
#endif

#ifndef NO_glPassThrough
JNIEXPORT void JNICALL GL_NATIVE(glPassThrough)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glPassThrough_FUNC);
	glPassThrough(arg0);
	GL_NATIVE_EXIT(env, that, glPassThrough_FUNC);
}
#endif

#ifndef NO_glPixelMapfv
JNIEXPORT void JNICALL GL_NATIVE(glPixelMapfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glPixelMapfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glPixelMapfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glPixelMapfv_FUNC);
}
#endif

#ifndef NO_glPixelMapuiv
JNIEXPORT void JNICALL GL_NATIVE(glPixelMapuiv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glPixelMapuiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glPixelMapuiv(arg0, arg1, (const GLuint *)lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glPixelMapuiv_FUNC);
}
#endif

#ifndef NO_glPixelMapusv
JNIEXPORT void JNICALL GL_NATIVE(glPixelMapusv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2)
{
	jshort *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glPixelMapusv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL);
	}
	glPixelMapusv(arg0, arg1, (const GLushort *)lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glPixelMapusv_FUNC);
}
#endif

#ifndef NO_glPixelStoref
JNIEXPORT void JNICALL GL_NATIVE(glPixelStoref)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glPixelStoref_FUNC);
	glPixelStoref(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPixelStoref_FUNC);
}
#endif

#ifndef NO_glPixelStorei
JNIEXPORT void JNICALL GL_NATIVE(glPixelStorei)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glPixelStorei_FUNC);
	glPixelStorei(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPixelStorei_FUNC);
}
#endif

#ifndef NO_glPixelTransferf
JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferf)
	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glPixelTransferf_FUNC);
	glPixelTransferf(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPixelTransferf_FUNC);
}
#endif

#ifndef NO_glPixelTransferi
JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferi)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glPixelTransferi_FUNC);
	glPixelTransferi(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPixelTransferi_FUNC);
}
#endif

#ifndef NO_glPixelZoom
JNIEXPORT void JNICALL GL_NATIVE(glPixelZoom)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glPixelZoom_FUNC);
	glPixelZoom(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPixelZoom_FUNC);
}
#endif

#ifndef NO_glPointSize
JNIEXPORT void JNICALL GL_NATIVE(glPointSize)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glPointSize_FUNC);
	glPointSize(arg0);
	GL_NATIVE_EXIT(env, that, glPointSize_FUNC);
}
#endif

#ifndef NO_glPolygonMode
JNIEXPORT void JNICALL GL_NATIVE(glPolygonMode)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glPolygonMode_FUNC);
	glPolygonMode(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPolygonMode_FUNC);
}
#endif

#ifndef NO_glPolygonOffset
JNIEXPORT void JNICALL GL_NATIVE(glPolygonOffset)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glPolygonOffset_FUNC);
	glPolygonOffset(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glPolygonOffset_FUNC);
}
#endif

#ifndef NO_glPolygonStipple
JNIEXPORT void JNICALL GL_NATIVE(glPolygonStipple)
	(JNIEnv *env, jclass that, jbyteArray arg0)
{
	jbyte *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glPolygonStipple_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
	}
	glPolygonStipple((GLubyte *)lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glPolygonStipple_FUNC);
}
#endif

#ifndef NO_glPopAttrib
JNIEXPORT void JNICALL GL_NATIVE(glPopAttrib)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glPopAttrib_FUNC);
	glPopAttrib();
	GL_NATIVE_EXIT(env, that, glPopAttrib_FUNC);
}
#endif

#ifndef NO_glPopClientAttrib
JNIEXPORT void JNICALL GL_NATIVE(glPopClientAttrib)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glPopClientAttrib_FUNC);
	glPopClientAttrib();
	GL_NATIVE_EXIT(env, that, glPopClientAttrib_FUNC);
}
#endif

#ifndef NO_glPopMatrix
JNIEXPORT void JNICALL GL_NATIVE(glPopMatrix)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glPopMatrix_FUNC);
	glPopMatrix();
	GL_NATIVE_EXIT(env, that, glPopMatrix_FUNC);
}
#endif

#ifndef NO_glPopName
JNIEXPORT void JNICALL GL_NATIVE(glPopName)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glPopName_FUNC);
	glPopName();
	GL_NATIVE_EXIT(env, that, glPopName_FUNC);
}
#endif

#ifndef NO_glPrioritizeTextures
JNIEXPORT void JNICALL GL_NATIVE(glPrioritizeTextures)
	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jfloatArray arg2)
{
	jint *lparg1=NULL;
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glPrioritizeTextures_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glPrioritizeTextures(arg0, (const GLuint *)lparg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
	}
	GL_NATIVE_EXIT(env, that, glPrioritizeTextures_FUNC);
}
#endif

#ifndef NO_glPushAttrib
JNIEXPORT void JNICALL GL_NATIVE(glPushAttrib)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glPushAttrib_FUNC);
	glPushAttrib(arg0);
	GL_NATIVE_EXIT(env, that, glPushAttrib_FUNC);
}
#endif

#ifndef NO_glPushClientAttrib
JNIEXPORT void JNICALL GL_NATIVE(glPushClientAttrib)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glPushClientAttrib_FUNC);
	glPushClientAttrib(arg0);
	GL_NATIVE_EXIT(env, that, glPushClientAttrib_FUNC);
}
#endif

#ifndef NO_glPushMatrix
JNIEXPORT void JNICALL GL_NATIVE(glPushMatrix)
	(JNIEnv *env, jclass that)
{
	GL_NATIVE_ENTER(env, that, glPushMatrix_FUNC);
	glPushMatrix();
	GL_NATIVE_EXIT(env, that, glPushMatrix_FUNC);
}
#endif

#ifndef NO_glPushName
JNIEXPORT void JNICALL GL_NATIVE(glPushName)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glPushName_FUNC);
	glPushName(arg0);
	GL_NATIVE_EXIT(env, that, glPushName_FUNC);
}
#endif

#ifndef NO_glRasterPos2d
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
{
	GL_NATIVE_ENTER(env, that, glRasterPos2d_FUNC);
	glRasterPos2d(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glRasterPos2d_FUNC);
}
#endif

#ifndef NO_glRasterPos2dv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos2dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glRasterPos2dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos2dv_FUNC);
}
#endif

#ifndef NO_glRasterPos2f
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glRasterPos2f_FUNC);
	glRasterPos2f(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glRasterPos2f_FUNC);
}
#endif

#ifndef NO_glRasterPos2fv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos2fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glRasterPos2fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos2fv_FUNC);
}
#endif

#ifndef NO_glRasterPos2i
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glRasterPos2i_FUNC);
	glRasterPos2i(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glRasterPos2i_FUNC);
}
#endif

#ifndef NO_glRasterPos2iv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos2iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glRasterPos2iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos2iv_FUNC);
}
#endif

#ifndef NO_glRasterPos2s
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
{
	GL_NATIVE_ENTER(env, that, glRasterPos2s_FUNC);
	glRasterPos2s(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glRasterPos2s_FUNC);
}
#endif

#ifndef NO_glRasterPos2sv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos2sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glRasterPos2sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos2sv_FUNC);
}
#endif

#ifndef NO_glRasterPos3d
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glRasterPos3d_FUNC);
	glRasterPos3d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glRasterPos3d_FUNC);
}
#endif

#ifndef NO_glRasterPos3dv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos3dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glRasterPos3dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos3dv_FUNC);
}
#endif

#ifndef NO_glRasterPos3f
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glRasterPos3f_FUNC);
	glRasterPos3f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glRasterPos3f_FUNC);
}
#endif

#ifndef NO_glRasterPos3fv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos3fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glRasterPos3fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos3fv_FUNC);
}
#endif

#ifndef NO_glRasterPos3i
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glRasterPos3i_FUNC);
	glRasterPos3i(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glRasterPos3i_FUNC);
}
#endif

#ifndef NO_glRasterPos3iv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos3iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glRasterPos3iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos3iv_FUNC);
}
#endif

#ifndef NO_glRasterPos3s
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glRasterPos3s_FUNC);
	glRasterPos3s(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glRasterPos3s_FUNC);
}
#endif

#ifndef NO_glRasterPos3sv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos3sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glRasterPos3sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos3sv_FUNC);
}
#endif

#ifndef NO_glRasterPos4d
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glRasterPos4d_FUNC);
	glRasterPos4d(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRasterPos4d_FUNC);
}
#endif

#ifndef NO_glRasterPos4dv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos4dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glRasterPos4dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos4dv_FUNC);
}
#endif

#ifndef NO_glRasterPos4f
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glRasterPos4f_FUNC);
	glRasterPos4f(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRasterPos4f_FUNC);
}
#endif

#ifndef NO_glRasterPos4fv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos4fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glRasterPos4fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos4fv_FUNC);
}
#endif

#ifndef NO_glRasterPos4i
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glRasterPos4i_FUNC);
	glRasterPos4i(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRasterPos4i_FUNC);
}
#endif

#ifndef NO_glRasterPos4iv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos4iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glRasterPos4iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos4iv_FUNC);
}
#endif

#ifndef NO_glRasterPos4s
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glRasterPos4s_FUNC);
	glRasterPos4s(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRasterPos4s_FUNC);
}
#endif

#ifndef NO_glRasterPos4sv
JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glRasterPos4sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glRasterPos4sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRasterPos4sv_FUNC);
}
#endif

#ifndef NO_glReadBuffer
JNIEXPORT void JNICALL GL_NATIVE(glReadBuffer)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glReadBuffer_FUNC);
	glReadBuffer(arg0);
	GL_NATIVE_EXIT(env, that, glReadBuffer_FUNC);
}
#endif

#ifndef NO_glReadPixels
JNIEXPORT void JNICALL GL_NATIVE(glReadPixels)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
{
	jint *lparg6=NULL;
	GL_NATIVE_ENTER(env, that, glReadPixels_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
	} else
#endif
	{
		if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);
	}
	glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
	} else
#endif
	{
		if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
	}
	GL_NATIVE_EXIT(env, that, glReadPixels_FUNC);
}
#endif

#ifndef NO_glRectd
JNIEXPORT void JNICALL GL_NATIVE(glRectd)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glRectd_FUNC);
	glRectd(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRectd_FUNC);
}
#endif

#ifndef NO_glRectdv
JNIEXPORT void JNICALL GL_NATIVE(glRectdv)
	(JNIEnv *env, jclass that, jdoubleArray arg0, jdoubleArray arg1)
{
	jdouble *lparg0=NULL;
	jdouble *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glRectdv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
	}
	glRectdv(lparg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRectdv_FUNC);
}
#endif

#ifndef NO_glRectf
JNIEXPORT void JNICALL GL_NATIVE(glRectf)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glRectf_FUNC);
	glRectf(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRectf_FUNC);
}
#endif

#ifndef NO_glRectfv
JNIEXPORT void JNICALL GL_NATIVE(glRectfv)
	(JNIEnv *env, jclass that, jfloatArray arg0, jfloatArray arg1)
{
	jfloat *lparg0=NULL;
	jfloat *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glRectfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
	}
	glRectfv(lparg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRectfv_FUNC);
}
#endif

#ifndef NO_glRecti
JNIEXPORT void JNICALL GL_NATIVE(glRecti)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glRecti_FUNC);
	glRecti(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRecti_FUNC);
}
#endif

#ifndef NO_glRectiv
JNIEXPORT void JNICALL GL_NATIVE(glRectiv)
	(JNIEnv *env, jclass that, jintArray arg0, jintArray arg1)
{
	jint *lparg0=NULL;
	jint *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glRectiv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
	}
	glRectiv(lparg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRectiv_FUNC);
}
#endif

#ifndef NO_glRects
JNIEXPORT void JNICALL GL_NATIVE(glRects)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glRects_FUNC);
	glRects(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRects_FUNC);
}
#endif

#ifndef NO_glRectsv
JNIEXPORT void JNICALL GL_NATIVE(glRectsv)
	(JNIEnv *env, jclass that, jshortArray arg0, jshortArray arg1)
{
	jshort *lparg0=NULL;
	jshort *lparg1=NULL;
	GL_NATIVE_ENTER(env, that, glRectsv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetPrimitiveArrayCritical(env, arg1, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
		if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);
	}
	glRectsv(lparg0, lparg1);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) (*env)->ReleasePrimitiveArrayCritical(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glRectsv_FUNC);
}
#endif

#ifndef NO_glRenderMode
JNIEXPORT jint JNICALL GL_NATIVE(glRenderMode)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc;
	GL_NATIVE_ENTER(env, that, glRenderMode_FUNC);
	rc = (jint)glRenderMode(arg0);
	GL_NATIVE_EXIT(env, that, glRenderMode_FUNC);
	return rc;
}
#endif

#ifndef NO_glRotated
JNIEXPORT void JNICALL GL_NATIVE(glRotated)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glRotated_FUNC);
	glRotated(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRotated_FUNC);
}
#endif

#ifndef NO_glRotatef
JNIEXPORT void JNICALL GL_NATIVE(glRotatef)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glRotatef_FUNC);
	glRotatef(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glRotatef_FUNC);
}
#endif

#ifndef NO_glScaled
JNIEXPORT void JNICALL GL_NATIVE(glScaled)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glScaled_FUNC);
	glScaled(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glScaled_FUNC);
}
#endif

#ifndef NO_glScalef
JNIEXPORT void JNICALL GL_NATIVE(glScalef)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glScalef_FUNC);
	glScalef(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glScalef_FUNC);
}
#endif

#ifndef NO_glScissor
JNIEXPORT void JNICALL GL_NATIVE(glScissor)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glScissor_FUNC);
	glScissor(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glScissor_FUNC);
}
#endif

#ifndef NO_glSelectBuffer
JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glSelectBuffer_FUNC);
	glSelectBuffer(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glSelectBuffer_FUNC);
}
#endif

#ifndef NO_glShadeModel
JNIEXPORT void JNICALL GL_NATIVE(glShadeModel)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glShadeModel_FUNC);
	glShadeModel(arg0);
	GL_NATIVE_EXIT(env, that, glShadeModel_FUNC);
}
#endif

#ifndef NO_glStencilFunc
JNIEXPORT void JNICALL GL_NATIVE(glStencilFunc)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glStencilFunc_FUNC);
	glStencilFunc(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glStencilFunc_FUNC);
}
#endif

#ifndef NO_glStencilMask
JNIEXPORT void JNICALL GL_NATIVE(glStencilMask)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glStencilMask_FUNC);
	glStencilMask(arg0);
	GL_NATIVE_EXIT(env, that, glStencilMask_FUNC);
}
#endif

#ifndef NO_glStencilOp
JNIEXPORT void JNICALL GL_NATIVE(glStencilOp)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glStencilOp_FUNC);
	glStencilOp(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glStencilOp_FUNC);
}
#endif

#ifndef NO_glTexCoord1d
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1d)
	(JNIEnv *env, jclass that, jdouble arg0)
{
	GL_NATIVE_ENTER(env, that, glTexCoord1d_FUNC);
	glTexCoord1d(arg0);
	GL_NATIVE_EXIT(env, that, glTexCoord1d_FUNC);
}
#endif

#ifndef NO_glTexCoord1dv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord1dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glTexCoord1dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord1dv_FUNC);
}
#endif

#ifndef NO_glTexCoord1f
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1f)
	(JNIEnv *env, jclass that, jfloat arg0)
{
	GL_NATIVE_ENTER(env, that, glTexCoord1f_FUNC);
	glTexCoord1f(arg0);
	GL_NATIVE_EXIT(env, that, glTexCoord1f_FUNC);
}
#endif

#ifndef NO_glTexCoord1fv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord1fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glTexCoord1fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord1fv_FUNC);
}
#endif

#ifndef NO_glTexCoord1i
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1i)
	(JNIEnv *env, jclass that, jint arg0)
{
	GL_NATIVE_ENTER(env, that, glTexCoord1i_FUNC);
	glTexCoord1i(arg0);
	GL_NATIVE_EXIT(env, that, glTexCoord1i_FUNC);
}
#endif

#ifndef NO_glTexCoord1iv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord1iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glTexCoord1iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord1iv_FUNC);
}
#endif

#ifndef NO_glTexCoord1s
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1s)
	(JNIEnv *env, jclass that, jshort arg0)
{
	GL_NATIVE_ENTER(env, that, glTexCoord1s_FUNC);
	glTexCoord1s(arg0);
	GL_NATIVE_EXIT(env, that, glTexCoord1s_FUNC);
}
#endif

#ifndef NO_glTexCoord1sv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord1sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glTexCoord1sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord1sv_FUNC);
}
#endif

#ifndef NO_glTexCoord2d
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
{
	GL_NATIVE_ENTER(env, that, glTexCoord2d_FUNC);
	glTexCoord2d(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glTexCoord2d_FUNC);
}
#endif

#ifndef NO_glTexCoord2dv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord2dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glTexCoord2dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord2dv_FUNC);
}
#endif

#ifndef NO_glTexCoord2f
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glTexCoord2f_FUNC);
	glTexCoord2f(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glTexCoord2f_FUNC);
}
#endif

#ifndef NO_glTexCoord2fv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord2fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glTexCoord2fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord2fv_FUNC);
}
#endif

#ifndef NO_glTexCoord2i
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glTexCoord2i_FUNC);
	glTexCoord2i(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glTexCoord2i_FUNC);
}
#endif

#ifndef NO_glTexCoord2iv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord2iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glTexCoord2iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord2iv_FUNC);
}
#endif

#ifndef NO_glTexCoord2s
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
{
	GL_NATIVE_ENTER(env, that, glTexCoord2s_FUNC);
	glTexCoord2s(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glTexCoord2s_FUNC);
}
#endif

#ifndef NO_glTexCoord2sv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord2sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glTexCoord2sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord2sv_FUNC);
}
#endif

#ifndef NO_glTexCoord3d
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glTexCoord3d_FUNC);
	glTexCoord3d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexCoord3d_FUNC);
}
#endif

#ifndef NO_glTexCoord3dv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord3dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glTexCoord3dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord3dv_FUNC);
}
#endif

#ifndef NO_glTexCoord3f
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glTexCoord3f_FUNC);
	glTexCoord3f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexCoord3f_FUNC);
}
#endif

#ifndef NO_glTexCoord3fv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord3fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glTexCoord3fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord3fv_FUNC);
}
#endif

#ifndef NO_glTexCoord3i
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glTexCoord3i_FUNC);
	glTexCoord3i(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexCoord3i_FUNC);
}
#endif

#ifndef NO_glTexCoord3iv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord3iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glTexCoord3iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord3iv_FUNC);
}
#endif

#ifndef NO_glTexCoord3s
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glTexCoord3s_FUNC);
	glTexCoord3s(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexCoord3s_FUNC);
}
#endif

#ifndef NO_glTexCoord3sv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord3sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glTexCoord3sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord3sv_FUNC);
}
#endif

#ifndef NO_glTexCoord4d
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glTexCoord4d_FUNC);
	glTexCoord4d(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glTexCoord4d_FUNC);
}
#endif

#ifndef NO_glTexCoord4dv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord4dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glTexCoord4dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord4dv_FUNC);
}
#endif

#ifndef NO_glTexCoord4f
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glTexCoord4f_FUNC);
	glTexCoord4f(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glTexCoord4f_FUNC);
}
#endif

#ifndef NO_glTexCoord4fv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord4fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glTexCoord4fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord4fv_FUNC);
}
#endif

#ifndef NO_glTexCoord4i
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glTexCoord4i_FUNC);
	glTexCoord4i(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glTexCoord4i_FUNC);
}
#endif

#ifndef NO_glTexCoord4iv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord4iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glTexCoord4iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord4iv_FUNC);
}
#endif

#ifndef NO_glTexCoord4s
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glTexCoord4s_FUNC);
	glTexCoord4s(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glTexCoord4s_FUNC);
}
#endif

#ifndef NO_glTexCoord4sv
JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoord4sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glTexCoord4sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoord4sv_FUNC);
}
#endif

#ifndef NO_glTexCoordPointer
JNIEXPORT void JNICALL GL_NATIVE(glTexCoordPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glTexCoordPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
	}
	glTexCoordPointer(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexCoordPointer_FUNC);
}
#endif

#ifndef NO_glTexEnvf
JNIEXPORT void JNICALL GL_NATIVE(glTexEnvf)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glTexEnvf_FUNC);
	glTexEnvf(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexEnvf_FUNC);
}
#endif

#ifndef NO_glTexEnvfv
JNIEXPORT void JNICALL GL_NATIVE(glTexEnvfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexEnvfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glTexEnvfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexEnvfv_FUNC);
}
#endif

#ifndef NO_glTexEnvi
JNIEXPORT void JNICALL GL_NATIVE(glTexEnvi)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glTexEnvi_FUNC);
	glTexEnvi(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexEnvi_FUNC);
}
#endif

#ifndef NO_glTexEnviv
JNIEXPORT void JNICALL GL_NATIVE(glTexEnviv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexEnviv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glTexEnviv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexEnviv_FUNC);
}
#endif

#ifndef NO_glTexGend
JNIEXPORT void JNICALL GL_NATIVE(glTexGend)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glTexGend_FUNC);
	glTexGend(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexGend_FUNC);
}
#endif

#ifndef NO_glTexGendv
JNIEXPORT void JNICALL GL_NATIVE(glTexGendv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
{
	jdouble *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexGendv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
	}
	glTexGendv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexGendv_FUNC);
}
#endif

#ifndef NO_glTexGenf
JNIEXPORT void JNICALL GL_NATIVE(glTexGenf)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glTexGenf_FUNC);
	glTexGenf(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexGenf_FUNC);
}
#endif

#ifndef NO_glTexGenfv
JNIEXPORT void JNICALL GL_NATIVE(glTexGenfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexGenfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glTexGenfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexGenfv_FUNC);
}
#endif

#ifndef NO_glTexGeni
JNIEXPORT void JNICALL GL_NATIVE(glTexGeni)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glTexGeni_FUNC);
	glTexGeni(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexGeni_FUNC);
}
#endif

#ifndef NO_glTexGeniv
JNIEXPORT void JNICALL GL_NATIVE(glTexGeniv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexGeniv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glTexGeniv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexGeniv_FUNC);
}
#endif

#ifndef NO_glTexImage1D
JNIEXPORT void JNICALL GL_NATIVE(glTexImage1D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jintArray arg7)
{
	jint *lparg7=NULL;
	GL_NATIVE_ENTER(env, that, glTexImage1D_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg7) lparg7 = (*env)->GetPrimitiveArrayCritical(env, arg7, NULL);
	} else
#endif
	{
		if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL);
	}
	glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, lparg7);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg7) (*env)->ReleasePrimitiveArrayCritical(env, arg7, lparg7, 0);
	} else
#endif
	{
		if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexImage1D_FUNC);
}
#endif

#ifndef NO_glTexImage2D
JNIEXPORT void JNICALL GL_NATIVE(glTexImage2D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jbyteArray arg8)
{
	jbyte *lparg8=NULL;
	GL_NATIVE_ENTER(env, that, glTexImage2D_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
	} else
#endif
	{
		if (arg8) lparg8 = (*env)->GetByteArrayElements(env, arg8, NULL);
	}
	glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
	} else
#endif
	{
		if (arg8) (*env)->ReleaseByteArrayElements(env, arg8, lparg8, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexImage2D_FUNC);
}
#endif

#ifndef NO_glTexParameterf
JNIEXPORT void JNICALL GL_NATIVE(glTexParameterf)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glTexParameterf_FUNC);
	glTexParameterf(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexParameterf_FUNC);
}
#endif

#ifndef NO_glTexParameterfv
JNIEXPORT void JNICALL GL_NATIVE(glTexParameterfv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
{
	jfloat *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexParameterfv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
	}
	glTexParameterfv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexParameterfv_FUNC);
}
#endif

#ifndef NO_glTexParameteri
JNIEXPORT void JNICALL GL_NATIVE(glTexParameteri)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glTexParameteri_FUNC);
	glTexParameteri(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTexParameteri_FUNC);
}
#endif

#ifndef NO_glTexParameteriv
JNIEXPORT void JNICALL GL_NATIVE(glTexParameteriv)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
{
	jint *lparg2=NULL;
	GL_NATIVE_ENTER(env, that, glTexParameteriv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) lparg2 = (*env)->GetPrimitiveArrayCritical(env, arg2, NULL);
	} else
#endif
	{
		if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
	}
	glTexParameteriv(arg0, arg1, lparg2);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg2) (*env)->ReleasePrimitiveArrayCritical(env, arg2, lparg2, 0);
	} else
#endif
	{
		if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexParameteriv_FUNC);
}
#endif

#ifndef NO_glTexSubImage1D
JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage1D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
{
	jint *lparg6=NULL;
	GL_NATIVE_ENTER(env, that, glTexSubImage1D_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) lparg6 = (*env)->GetPrimitiveArrayCritical(env, arg6, NULL);
	} else
#endif
	{
		if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);
	}
	glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg6) (*env)->ReleasePrimitiveArrayCritical(env, arg6, lparg6, 0);
	} else
#endif
	{
		if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexSubImage1D_FUNC);
}
#endif

#ifndef NO_glTexSubImage2D
JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage2D)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jintArray arg8)
{
	jint *lparg8=NULL;
	GL_NATIVE_ENTER(env, that, glTexSubImage2D_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg8) lparg8 = (*env)->GetPrimitiveArrayCritical(env, arg8, NULL);
	} else
#endif
	{
		if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL);
	}
	glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg8) (*env)->ReleasePrimitiveArrayCritical(env, arg8, lparg8, 0);
	} else
#endif
	{
		if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);
	}
	GL_NATIVE_EXIT(env, that, glTexSubImage2D_FUNC);
}
#endif

#ifndef NO_glTranslated
JNIEXPORT void JNICALL GL_NATIVE(glTranslated)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glTranslated_FUNC);
	glTranslated(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTranslated_FUNC);
}
#endif

#ifndef NO_glTranslatef
JNIEXPORT void JNICALL GL_NATIVE(glTranslatef)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glTranslatef_FUNC);
	glTranslatef(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glTranslatef_FUNC);
}
#endif

#ifndef NO_glVertex2d
JNIEXPORT void JNICALL GL_NATIVE(glVertex2d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
{
	GL_NATIVE_ENTER(env, that, glVertex2d_FUNC);
	glVertex2d(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glVertex2d_FUNC);
}
#endif

#ifndef NO_glVertex2dv
JNIEXPORT void JNICALL GL_NATIVE(glVertex2dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex2dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glVertex2dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex2dv_FUNC);
}
#endif

#ifndef NO_glVertex2f
JNIEXPORT void JNICALL GL_NATIVE(glVertex2f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
{
	GL_NATIVE_ENTER(env, that, glVertex2f_FUNC);
	glVertex2f(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glVertex2f_FUNC);
}
#endif

#ifndef NO_glVertex2fv
JNIEXPORT void JNICALL GL_NATIVE(glVertex2fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex2fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glVertex2fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex2fv_FUNC);
}
#endif

#ifndef NO_glVertex2i
JNIEXPORT void JNICALL GL_NATIVE(glVertex2i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	GL_NATIVE_ENTER(env, that, glVertex2i_FUNC);
	glVertex2i(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glVertex2i_FUNC);
}
#endif

#ifndef NO_glVertex2iv
JNIEXPORT void JNICALL GL_NATIVE(glVertex2iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex2iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glVertex2iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex2iv_FUNC);
}
#endif

#ifndef NO_glVertex2s
JNIEXPORT void JNICALL GL_NATIVE(glVertex2s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
{
	GL_NATIVE_ENTER(env, that, glVertex2s_FUNC);
	glVertex2s(arg0, arg1);
	GL_NATIVE_EXIT(env, that, glVertex2s_FUNC);
}
#endif

#ifndef NO_glVertex2sv
JNIEXPORT void JNICALL GL_NATIVE(glVertex2sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex2sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glVertex2sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex2sv_FUNC);
}
#endif

#ifndef NO_glVertex3d
JNIEXPORT void JNICALL GL_NATIVE(glVertex3d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
{
	GL_NATIVE_ENTER(env, that, glVertex3d_FUNC);
	glVertex3d(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glVertex3d_FUNC);
}
#endif

#ifndef NO_glVertex3dv
JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex3dv_FUNC);
	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	glVertex3dv(lparg0);
	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	GL_NATIVE_EXIT(env, that, glVertex3dv_FUNC);
}
#endif

#ifndef NO_glVertex3f
JNIEXPORT void JNICALL GL_NATIVE(glVertex3f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
{
	GL_NATIVE_ENTER(env, that, glVertex3f_FUNC);
	glVertex3f(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glVertex3f_FUNC);
}
#endif

#ifndef NO_glVertex3fv
JNIEXPORT void JNICALL GL_NATIVE(glVertex3fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex3fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glVertex3fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex3fv_FUNC);
}
#endif

#ifndef NO_glVertex3i
JNIEXPORT void JNICALL GL_NATIVE(glVertex3i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
{
	GL_NATIVE_ENTER(env, that, glVertex3i_FUNC);
	glVertex3i(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glVertex3i_FUNC);
}
#endif

#ifndef NO_glVertex3iv
JNIEXPORT void JNICALL GL_NATIVE(glVertex3iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex3iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glVertex3iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex3iv_FUNC);
}
#endif

#ifndef NO_glVertex3s
JNIEXPORT void JNICALL GL_NATIVE(glVertex3s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
{
	GL_NATIVE_ENTER(env, that, glVertex3s_FUNC);
	glVertex3s(arg0, arg1, arg2);
	GL_NATIVE_EXIT(env, that, glVertex3s_FUNC);
}
#endif

#ifndef NO_glVertex3sv
JNIEXPORT void JNICALL GL_NATIVE(glVertex3sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex3sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glVertex3sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex3sv_FUNC);
}
#endif

#ifndef NO_glVertex4d
JNIEXPORT void JNICALL GL_NATIVE(glVertex4d)
	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
{
	GL_NATIVE_ENTER(env, that, glVertex4d_FUNC);
	glVertex4d(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glVertex4d_FUNC);
}
#endif

#ifndef NO_glVertex4dv
JNIEXPORT void JNICALL GL_NATIVE(glVertex4dv)
	(JNIEnv *env, jclass that, jdoubleArray arg0)
{
	jdouble *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex4dv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
	}
	glVertex4dv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex4dv_FUNC);
}
#endif

#ifndef NO_glVertex4f
JNIEXPORT void JNICALL GL_NATIVE(glVertex4f)
	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
{
	GL_NATIVE_ENTER(env, that, glVertex4f_FUNC);
	glVertex4f(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glVertex4f_FUNC);
}
#endif

#ifndef NO_glVertex4fv
JNIEXPORT void JNICALL GL_NATIVE(glVertex4fv)
	(JNIEnv *env, jclass that, jfloatArray arg0)
{
	jfloat *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex4fv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
	}
	glVertex4fv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex4fv_FUNC);
}
#endif

#ifndef NO_glVertex4i
JNIEXPORT void JNICALL GL_NATIVE(glVertex4i)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glVertex4i_FUNC);
	glVertex4i(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glVertex4i_FUNC);
}
#endif

#ifndef NO_glVertex4iv
JNIEXPORT void JNICALL GL_NATIVE(glVertex4iv)
	(JNIEnv *env, jclass that, jintArray arg0)
{
	jint *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex4iv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
	}
	glVertex4iv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex4iv_FUNC);
}
#endif

#ifndef NO_glVertex4s
JNIEXPORT void JNICALL GL_NATIVE(glVertex4s)
	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
{
	GL_NATIVE_ENTER(env, that, glVertex4s_FUNC);
	glVertex4s(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glVertex4s_FUNC);
}
#endif

#ifndef NO_glVertex4sv
JNIEXPORT void JNICALL GL_NATIVE(glVertex4sv)
	(JNIEnv *env, jclass that, jshortArray arg0)
{
	jshort *lparg0=NULL;
	GL_NATIVE_ENTER(env, that, glVertex4sv_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) lparg0 = (*env)->GetPrimitiveArrayCritical(env, arg0, NULL);
	} else
#endif
	{
		if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
	}
	glVertex4sv(lparg0);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) (*env)->ReleasePrimitiveArrayCritical(env, arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertex4sv_FUNC);
}
#endif

#ifndef NO_glVertexPointer
JNIEXPORT void JNICALL GL_NATIVE(glVertexPointer)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
{
	jint *lparg3=NULL;
	GL_NATIVE_ENTER(env, that, glVertexPointer_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) lparg3 = (*env)->GetPrimitiveArrayCritical(env, arg3, NULL);
	} else
#endif
	{
		if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
	}
	glVertexPointer(arg0, arg1, arg2, lparg3);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg3) (*env)->ReleasePrimitiveArrayCritical(env, arg3, lparg3, 0);
	} else
#endif
	{
		if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
	}
	GL_NATIVE_EXIT(env, that, glVertexPointer_FUNC);
}
#endif

#ifndef NO_glViewport
JNIEXPORT void JNICALL GL_NATIVE(glViewport)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
{
	GL_NATIVE_ENTER(env, that, glViewport_FUNC);
	glViewport(arg0, arg1, arg2, arg3);
	GL_NATIVE_EXIT(env, that, glViewport_FUNC);
}
#endif