Initial revision

35 files changed, 144462 insertions, 0 deletions

diff --git a/CNativeCode/.OpenGL_JauJNI12_dynfuncs.c.swp b/CNativeCode/.OpenGL_JauJNI12_dynfuncs.c.swp
new file mode 100644
index 0000000..a8a6df5
--- /dev/null
+++ b/CNativeCode/.OpenGL_JauJNI12_dynfuncs.c.swp
diff --git a/CNativeCode/GLCallbackHelperJNI.c b/CNativeCode/GLCallbackHelperJNI.c
new file mode 100644
index 0000000..2039560
--- /dev/null
+++ b/CNativeCode/GLCallbackHelperJNI.c
@@ -0,0 +1,238 @@
+
+#include "GLCallbackHelperJNI.h"
+#include "jnitools.h"
+
+#ifndef _WIN32_
+  #ifdef macintosh
+	#include <agl.h>
+	#include <string.h>
+  #else
+	#include <GL/glx.h>
+  #endif
+#endif
+
+/*
+#define DEBUG
+*/
+
+static CallbackNode * pCallbackNodeRoot = 0;
+
+void LIBAPIENTRY PrintCallbackEntry(const char *title, CallbackEntry * cbe)
+{
+	if(cbe==NULL)
+	{
+		printf("%s> NULL cbe/cbn entry\n", title);
+		return;
+	}
+
+	printf("%s> cbe entry 4 glu-obj=%ld, glx:=%ld (env=%ld, jobj=%ld)\n", 
+		title, (long)(cbe->cb_obj), (long)(cbe->glx),
+		(long)(cbe->env), (long)(cbe->jobj));
+
+	printf(" which, method, argNumber, signature\n");
+	printf(" %d %s %d: %s\n", 
+		cbe->which, 
+		cbe->methodName, 
+		cbe->argListNumber, 
+		cbe->signature);
+
+	printf(" array element number\n");
+	printf(" %d %d %d %d %d\n",
+		cbe->arrayLen1, 
+		cbe->arrayLen2, 
+		cbe->arrayLen3, 
+		cbe->arrayLen4, 
+		cbe->arrayLen5);
+	fflush(NULL);
+}
+
+void LIBAPIENTRY PrintCallbackNode(const char *title, CallbackNode * cbn)
+{
+	CallbackEntry * cbe=NULL;
+	if(cbn!=NULL) cbe=cbn->this;
+	PrintCallbackEntry(title, cbe);
+}
+
+#ifdef DEBUG
+	#define DBG_PRINT_CBE(a,b) PrintCallbackEntry(a,b)
+	#define DBG_PRINT_CBN(a,b) PrintCallbackNode(a,b)
+#else
+	#define DBG_PRINT_CBE(a,b)
+	#define DBG_PRINT_CBN(a,b)
+#endif
+
+static void CleanCallbackEntry(CallbackEntry * cbe)
+{
+	DBG_PRINT_CBE("CleanCallbackEntry", cbe);
+
+	if(cbe==NULL) return;
+	(*(cbe->env))->DeleteGlobalRef(cbe->env, cbe->jobj);
+	cbe->jobj=0;
+	if(cbe->methodName!=NULL)
+	{
+		free(cbe->methodName);
+		cbe->methodName=NULL;
+	}
+	if(cbe->signature!=NULL)
+	{
+		free(cbe->signature);
+		cbe->signature=NULL;
+	}
+	cbe->argListNumber=0;
+	cbe->arrayLen1=0;
+	cbe->arrayLen2=0;
+	cbe->arrayLen3=0;
+	cbe->arrayLen4=0;
+	cbe->arrayLen5=0;
+	cbe->cb_obj=NULL;
+	cbe->which=0;
+	cbe->glx=0;
+	cbe->env=NULL;
+}
+
+CallbackNode * LIBAPIENTRY LastCallbackNode()
+{
+	CallbackNode * cbn = pCallbackNodeRoot;
+	if(cbn==NULL) return NULL;
+
+	while(cbn->next!=NULL)
+		cbn=cbn->next;
+
+	return cbn;
+}
+
+CallbackNode * LIBAPIENTRY FindNextCallbackNodeOfCbObj(void *cb_obj)
+{
+	CallbackNode * cbn = pCallbackNodeRoot;
+
+	while(cbn!=NULL && cbn->this->cb_obj!=cb_obj)
+	{
+		cbn=cbn->next;
+	}
+	return cbn;
+}
+
+CallbackNode * LIBAPIENTRY FindCallbackNode(GLenum which, jlong glx)
+{
+	CallbackNode * cbn = pCallbackNodeRoot;
+
+	#ifdef DEBUG
+		CallbackEntry * cbe = NULL;
+		printf("FindCallbackNode> which:=%d, glx:=%ld\n",
+			which, (long)glx);
+		while(cbn!=NULL)
+		{
+			cbe=cbn->this;
+			printf(" test cbe(%s %s): which:=%d, glx:=%ld\n",
+				cbe->methodName, cbe->signature,
+				cbe->which, (long)(cbe->glx));
+
+			if(cbe->which==which && cbe->glx==glx)
+				break;
+			cbn=cbn->next;
+		}
+	#else
+		while(cbn!=NULL && 
+		      (cbn->this->which!=which || cbn->this->glx!=glx)
+		     )
+			cbn=cbn->next;
+	#endif
+
+	return cbn;
+}
+
+CallbackEntry * LIBAPIENTRY FindCallbackEntry(GLenum which, jlong glx)
+{
+	CallbackNode * cbn = FindCallbackNode(which, glx);
+	if(cbn==NULL) return NULL;
+	return cbn->this;
+}
+
+void  LIBAPIENTRY AddCallbackNode(JNIEnv * env, jobject jobj, 
+		      const char *methodName, const char *signature,
+		      int arrayLen1, int arrayLen2, int arrayLen3,
+		      int arrayLen4, int arrayLen5,
+		      void *cb_obj, GLenum which, jlong glx)
+{
+	CallbackNode * cbn = NULL;
+	CallbackNode * last_cbn = NULL;
+	CallbackEntry * cbe = NULL;
+
+	cbn = FindCallbackNode (which, glx);
+	if(cbn != NULL)
+	{
+		cbe = cbn->this;
+		CleanCallbackEntry(cbe);
+	} else {
+		cbe = calloc(1, sizeof(CallbackEntry));
+	}
+
+	cbe->env=env;
+	cbe->jobj= (*env)->NewGlobalRef(env, jobj);
+	if(methodName!=NULL)
+	{
+		cbe->methodName=calloc(strlen(methodName)+1, 1);
+		strcpy(cbe->methodName, methodName);
+	}
+	if(signature!=NULL)
+	{
+		cbe->signature=calloc(strlen(signature)+1, 1);
+		strcpy(cbe->signature, signature);
+	}
+	cbe->argListNumber= jnitoolsGetArgNumber(env, signature, cbe->methodName);
+	cbe->arrayLen1=arrayLen1;
+	cbe->arrayLen2=arrayLen2;
+	cbe->arrayLen3=arrayLen3;
+	cbe->arrayLen4=arrayLen4;
+	cbe->arrayLen5=arrayLen5;
+	cbe->cb_obj=cb_obj;
+	cbe->which=which;
+	cbe->glx=glx;
+
+	if(cbn == NULL)
+	{
+		cbn = calloc(1, sizeof(CallbackNode)); 
+		cbn->this = cbe;
+		last_cbn = LastCallbackNode();
+		if(last_cbn==NULL)
+			pCallbackNodeRoot=cbn;
+		else {
+			last_cbn->next=cbn;
+			cbn->prev=last_cbn;
+		}
+	}
+	DBG_PRINT_CBN("AddCallbackNode", cbn);
+}
+
+void  LIBAPIENTRY RemoveCallbackNodes(void *cb_obj)
+{
+	CallbackNode * cbn =  NULL;
+	while ( (cbn =  FindNextCallbackNodeOfCbObj(cb_obj) ) != NULL )
+	{
+		DBG_PRINT_CBN("RemoveCallbackNodes", cbn);
+		if(cbn->prev!=NULL)
+			cbn->prev->next=cbn->next;
+		else
+			pCallbackNodeRoot=cbn->next;
+		if(cbn->next!=NULL)
+			cbn->next->prev=cbn->prev;
+		CleanCallbackEntry(cbn->this);
+		free(cbn->this);
+		free(cbn);
+	}
+}
+
+jlong  LIBAPIENTRY GetCurrentGLContext()
+{
+	#ifdef _WIN32_
+                return (jlong) wglGetCurrentContext();
+        #else
+          #ifdef macintosh
+                return (jlong) aglGetCurrentContext();
+          #else
+                return (jlong) glXGetCurrentContext();   
+	  #endif
+        #endif
+}
+
+
diff --git a/CNativeCode/GLCallbackHelperJNI.h b/CNativeCode/GLCallbackHelperJNI.h
new file mode 100644
index 0000000..102f65a
--- /dev/null
+++ b/CNativeCode/GLCallbackHelperJNI.h
@@ -0,0 +1,71 @@
+
+#ifndef GLCALLBACKHELPERJNI
+	#define GLCALLBACKHELPERJNI
+
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <stdarg.h>
+
+	#ifdef _WIN32_
+		#include "winstuff.h"
+	#endif
+
+	#include <jni.h>
+
+	#include<GL/gl.h>
+	#include <GL/glu.h>
+
+	#ifndef LIBAPIENTRY
+		#define LIBAPIENTRY
+	#endif
+	#ifndef LIBAPI
+		#define LIBAPI
+	#endif
+
+	typedef struct {
+		/* The Java Handles */
+		JNIEnv *env;		/* non-copy */
+		jobject jobj;		/* copy */
+		char *methodName;	/* copy */
+		char *signature;	/* copy */
+		int argListNumber;	/* copy */
+		int arrayLen1;	/* copy */
+		int arrayLen2;	/* copy */
+		int arrayLen3;	/* copy */
+		int arrayLen4;	/* copy */
+		int arrayLen5;	/* copy */
+
+		/* The Native Handles */
+		void *cb_obj; /* non-copy, the tesselator, quadratics, etc. object */
+		GLenum which; /* copy, the function type */
+		jlong glx; /* copy, the GL-Context */
+	} CallbackEntry;
+
+	typedef struct _CallbackNode {
+		struct _CallbackNode *prev;
+		CallbackEntry *this;
+		struct _CallbackNode *next;
+	} CallbackNode;
+
+	LIBAPI void LIBAPIENTRY PrintCallbackEntry(const char *title, CallbackEntry * cbe);
+
+	LIBAPI void LIBAPIENTRY PrintCallbackNode(const char *title, CallbackNode * cbn);
+
+	LIBAPI CallbackNode * LIBAPIENTRY LastCallbackNode();
+
+	LIBAPI CallbackNode * LIBAPIENTRY FindNextCallbackNodeOfCbObj(void *cb_obj);
+	LIBAPI CallbackNode * LIBAPIENTRY FindCallbackNode(GLenum which, jlong glx);
+
+	LIBAPI CallbackEntry * LIBAPIENTRY FindCallbackEntry(GLenum which, jlong glx);
+
+	LIBAPI void  LIBAPIENTRY AddCallbackNode(JNIEnv * env, jobject jobj, 
+			      const char *methodName, const char *signature,
+			      int arrayLen1, int arrayLen2, int arrayLen3,
+		      	      int arrayLen4, int arrayLen5,
+			      void *cb_obj, GLenum which, jlong glx);
+
+	LIBAPI void  LIBAPIENTRY RemoveCallbackNodes(void *cb_obj);
+
+	LIBAPI jlong  LIBAPIENTRY GetCurrentGLContext();
+
+#endif
diff --git a/CNativeCode/GLUCallbackJNI.c b/CNativeCode/GLUCallbackJNI.c
new file mode 100644
index 0000000..ef2da51
--- /dev/null
+++ b/CNativeCode/GLUCallbackJNI.c
@@ -0,0 +1,639 @@
+
+#include "GLCallbackHelperJNI.h"
+#include "GLUCallbackJNI.h"
+#include "jnitools.h"
+
+void LIBAPIENTRY cbf_GLU_TESS_BEGIN (GLenum type)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	CallbackEntry * cbe = NULL;
+
+	cbe = FindCallbackEntry(GLU_TESS_BEGIN, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+	{
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	}
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, id, (jint)type);
+}
+
+void LIBAPIENTRY cbf_GLU_TESS_BEGIN_DATA (GLenum type, void *udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt=0;
+	jarray arr=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_BEGIN_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<2)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr = jnitoolsNativeArray2JavaArray (env, jbt, udata,  cbe->arrayLen1, cbe->methodName, 2);
+
+	if(arr!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, (jint)type, arr);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr, jbt, 
+						     udata,  cbe->arrayLen1, cbe->methodName, 2);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_EDGE_FLAG (GLboolean flag)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_EDGE_FLAG, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, id, (jboolean)flag);
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_EDGE_FLAG_DATA (GLboolean flag, void *udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt=0;
+	jarray arr=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_EDGE_FLAG_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<2)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr = jnitoolsNativeArray2JavaArray (env, jbt, udata,  cbe->arrayLen1, cbe->methodName, 2);
+
+	if(arr!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, (jboolean)flag, arr);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr, jbt, 
+						     udata,  cbe->arrayLen1, cbe->methodName, 2);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_VERTEX (void * vdata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt=0;
+	jarray arr=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_VERTEX, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<1)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt = jnitoolsGetJavaBasicType(env,cbe->signature, 0, cbe->methodName);
+	arr = jnitoolsNativeArray2JavaArray (env, jbt, vdata,  cbe->arrayLen1, cbe->methodName, 1);
+
+	if(arr!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, arr);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr, jbt, 
+						     vdata,  cbe->arrayLen1, cbe->methodName, 1);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_VERTEX_DATA (void * vdata, void * udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt0=0;
+	jarray arr0=0;
+	JavaBasicType jbt1=0;
+	jarray arr1=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_VERTEX_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<2)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt0 = jnitoolsGetJavaBasicType(env,cbe->signature, 0, cbe->methodName);
+	arr0 = jnitoolsNativeArray2JavaArray (env, jbt0, vdata,  cbe->arrayLen1, cbe->methodName, 1);
+	jbt1 = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr1 = jnitoolsNativeArray2JavaArray (env, jbt1, udata,  cbe->arrayLen2, cbe->methodName, 2);
+
+	if(arr0!=0 && arr1!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, arr0, arr1);
+
+		jnitoolsReleaseJavaArray2NativeArray (env, arr0, jbt0, 
+						     udata,  cbe->arrayLen1, cbe->methodName, 1);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr1, jbt1, 
+						     udata,  cbe->arrayLen2, cbe->methodName, 2);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_END (void)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_END, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, id);
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_END_DATA (void * udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt=0;
+	jarray arr=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_END_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<1)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt = jnitoolsGetJavaBasicType(env,cbe->signature, 0, cbe->methodName);
+	arr = jnitoolsNativeArray2JavaArray (env, jbt, udata,  cbe->arrayLen1, cbe->methodName, 1);
+
+	if(arr!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, arr);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr, jbt, 
+						     udata,  cbe->arrayLen1, cbe->methodName, 1);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_ERROR (GLenum errno)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_ERROR, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, id, (jint)errno);
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_ERROR_DATA (GLenum errno, void * udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt=0;
+	jarray arr=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_ERROR_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<2)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	jbt = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr = jnitoolsNativeArray2JavaArray (env, jbt, udata,  cbe->arrayLen1, cbe->methodName, 2);
+
+	if(arr!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, (jint)errno, arr);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr, jbt, 
+						     udata,  cbe->arrayLen1, cbe->methodName, 2);
+	}
+} 
+
+void LIBAPIENTRY cbf_GLU_TESS_COMBINE (GLdouble coords[3], void *vdata[4],
+				   GLfloat weight[4], void **outdata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt0=0;
+	jarray arr0=0;
+	JavaBasicType jbt1=0;
+	jarray arr1=0;
+	JavaBasicType jbt2=0;
+	jarray arr2=0;
+	JavaBasicType jbt3=0;
+	jarray arr3=0;
+	void * combdata = NULL;
+	CallbackEntry * cbe = NULL;
+
+	cbe = FindCallbackEntry(GLU_TESS_COMBINE, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<4)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	if(cbe->arrayLen1>3)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "First Array of GLU_TESS_COMBINE cannot exceed 3 elements !");
+		return;
+	}
+	if(cbe->arrayLen2%4!=0)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "Secound Array of GLU_TESS_COMBINE must be a multiple of 4 !");
+		return;
+	}
+	if(cbe->arrayLen3>4)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "First Array of GLU_TESS_COMBINE cannot exceed 4 elements !");
+		return;
+	}
+	jbt0 = jnitoolsGetJavaBasicType(env,cbe->signature, 0, cbe->methodName);
+	arr0 = jnitoolsNativeArray2JavaArray (env, jbt0, coords, cbe->arrayLen1, cbe->methodName, 1);
+	jbt1 = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr1 = jnitoolsNativePtrArray2JavaArray (env, jbt1, vdata, 4, cbe->arrayLen2, cbe->methodName, 2);
+	jbt2 = jnitoolsGetJavaBasicType(env,cbe->signature, 2, cbe->methodName);
+	arr2 = jnitoolsNativeArray2JavaArray (env, jbt2, weight, cbe->arrayLen3, cbe->methodName, 3);
+
+	jbt3 = jnitoolsGetJavaBasicType(env,cbe->signature, 3, cbe->methodName);
+	combdata = jnitoolsCreateNativeArray (jbt3, cbe->arrayLen4, cbe->methodName);
+	arr3 = jnitoolsNativeArray2JavaArray (env, jbt3, combdata, cbe->arrayLen4, cbe->methodName, 4);
+
+	if(arr0!=0 && arr1!=0 && arr2!=0 && arr3!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, arr0, arr1, arr2, arr3);
+
+		jnitoolsReleaseJavaArray2NativeArray (env, arr0, jbt0, coords, 
+							cbe->arrayLen1, cbe->methodName, 1);
+		jnitoolsReleaseJavaArray2NativeArrayPtr(env, arr1, jbt1, vdata, 
+							4, cbe->arrayLen2, cbe->methodName, 2); 
+		jnitoolsReleaseJavaArray2NativeArray (env, arr2, jbt2, weight, 
+							cbe->arrayLen3, cbe->methodName, 3);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr3, jbt3, combdata,
+							cbe->arrayLen4, cbe->methodName, 4);
+		*outdata=combdata;
+	}
+}
+
+void LIBAPIENTRY cbf_GLU_TESS_COMBINE_DATA (GLdouble coords[3], void *vdata[4],
+					GLfloat weight[4], void **outdata,
+					void *udata)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+	JavaBasicType jbt0=0;
+	jarray arr0=0;
+	JavaBasicType jbt1=0;
+	jarray arr1=0;
+	JavaBasicType jbt2=0;
+	jarray arr2=0;
+	JavaBasicType jbt3=0;
+	jarray arr3=0;
+	JavaBasicType jbt4=0;
+	jarray arr4=0;
+	void * combdata = NULL;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_TESS_COMBINE_DATA, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	if(cbe->argListNumber<5)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "too few arguments in registered callback function");
+		return;
+	}
+	if(cbe->arrayLen1>3)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "First Array of GLU_TESS_COMBINE_DATA cannot exceed 3 elements !");
+		return;
+	}
+	if(cbe->arrayLen2%4!=0)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "Secound Array of GLU_TESS_COMBINE_DATA must be a multiple of 4 !");
+		return;
+	}
+	if(cbe->arrayLen3>4)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "First Array of GLU_TESS_COMBINE_DATA cannot exceed 4 elements !");
+		return;
+	}
+	jbt0 = jnitoolsGetJavaBasicType(env,cbe->signature, 0, cbe->methodName);
+	arr0 = jnitoolsNativeArray2JavaArray (env, jbt0, coords, cbe->arrayLen1, cbe->methodName, 1);
+	jbt1 = jnitoolsGetJavaBasicType(env,cbe->signature, 1, cbe->methodName);
+	arr1 = jnitoolsNativePtrArray2JavaArray (env, jbt1, vdata, 4, cbe->arrayLen2, cbe->methodName, 2);
+	jbt2 = jnitoolsGetJavaBasicType(env,cbe->signature, 2, cbe->methodName);
+	arr2 = jnitoolsNativeArray2JavaArray (env, jbt2, weight, cbe->arrayLen3, cbe->methodName, 3);
+
+	jbt3 = jnitoolsGetJavaBasicType(env,cbe->signature, 3, cbe->methodName);
+	combdata = jnitoolsCreateNativeArray (jbt3, cbe->arrayLen2, cbe->methodName);
+	arr3 = jnitoolsNativeArray2JavaArray (env, jbt3, combdata, cbe->arrayLen4, cbe->methodName, 4);
+	jbt4 = jnitoolsGetJavaBasicType(env,cbe->signature, 4, cbe->methodName);
+	arr4 = jnitoolsNativeArray2JavaArray (env, jbt4, udata, cbe->arrayLen5, cbe->methodName, 5);
+
+	if(arr0!=0 && arr1!=0 && arr2!=0 && arr3!=0 && arr4!=0)
+	{
+		(*env)->CallVoidMethod(env, obj, id, arr0, arr1, arr2, arr3);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr0, jbt0, coords, 
+							cbe->arrayLen1, cbe->methodName, 1);
+		jnitoolsReleaseJavaArray2NativeArrayPtr(env, arr1, jbt1, vdata, 
+							4, cbe->arrayLen2, cbe->methodName, 2); 
+		jnitoolsReleaseJavaArray2NativeArray (env, arr2, jbt2, weight, 
+							cbe->arrayLen3, cbe->methodName, 3);
+		jnitoolsReleaseJavaArray2NativeArray (env, arr3, jbt3, combdata,
+							cbe->arrayLen4, cbe->methodName, 4);
+		*outdata=combdata;
+		jnitoolsReleaseJavaArray2NativeArray (env, arr4, jbt4, udata,  
+							cbe->arrayLen5, cbe->methodName, 5);
+	}
+}
+
+void LIBAPIENTRY cbf_GLU_ERROR (GLenum errno)
+{
+	JNIEnv * env = NULL;
+	jobject obj = 0;
+	jclass oclass=0;
+	jmethodID id=0;
+
+	CallbackEntry * cbe = FindCallbackEntry(GLU_ERROR, GetCurrentGLContext());
+
+	if(cbe==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback entry");
+		return;
+	}
+	env = cbe->env;
+	obj = cbe->jobj;
+  	oclass = (jclass) (*env)->GetObjectClass(env, obj);
+	if(oclass!=0)
+		id = (*env)->GetMethodID(env,oclass,cbe->methodName,cbe->signature) ;
+	if(id==NULL)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+			    "could not find the java callback method: %s %s",
+			    cbe->methodName, cbe->signature);
+		return;
+	}
+
+	(*env)->CallVoidMethod(env, obj, id, (jint)errno);
+} 
+
+
diff --git a/CNativeCode/GLUCallbackJNI.h b/CNativeCode/GLUCallbackJNI.h
new file mode 100644
index 0000000..58649fe
--- /dev/null
+++ b/CNativeCode/GLUCallbackJNI.h
@@ -0,0 +1,62 @@
+
+#ifndef GLUCALLBACKJNI
+	#define GLUCALLBACKJNI
+
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <stdarg.h>
+
+	#ifdef _WIN32_
+		#include "winstuff.h"
+	#endif
+
+	#include <jni.h>
+
+	#include<GL/gl.h>
+	#include <GL/glu.h>
+
+	#ifndef LIBAPIENTRY
+		#define LIBAPIENTRY
+	#endif
+	#ifndef LIBAPI
+		#define LIBAPI
+	#endif
+
+	typedef int (*CBF_ANY_FUNCTION) (); 
+
+	typedef void (*CBF_GLU_TESS_BEGIN) (GLenum type); 
+	typedef void (*CBF_GLU_TESS_BEGIN_DATA) (GLenum type, void *udata); 
+	typedef void (*CBF_GLU_TESS_EDGE_FLAG) (GLboolean flag); 
+	typedef void (*CBF_GLU_TESS_EDGE_FLAG_DATA) (GLboolean flag, void *udata); 
+	typedef void (*CBF_GLU_TESS_VERTEX) (void * vdata); 
+	typedef void (*CBF_GLU_TESS_VERTEX_DATA) (void * vdata, void * udata); 
+	typedef void (*CBF_GLU_TESS_END) (void); 
+	typedef void (*CBF_GLU_TESS_END_DATA) (void * udata); 
+	typedef void (*CBF_GLU_TESS_ERROR) (GLenum errno); 
+	typedef void (*CBF_GLU_TESS_ERROR_DATA) (GLenum errno, void * udata); 
+	typedef void (*CBF_GLU_TESS_COMBINE) (GLdouble coords[3], void *vdata[4],
+					     GLfloat weight[4], void **outdata);
+	typedef void (*CBF_GLU_TESS_COMBINE_DATA) (GLdouble coords[3], void *vdata[4],
+					          GLfloat weight[4], void **outdata,
+					          void *udata);
+	typedef void (*CBF_GLU_ERROR) (GLenum errno); 
+
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_BEGIN (GLenum type);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_BEGIN_DATA (GLenum type, void *udata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_EDGE_FLAG (GLboolean flag);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_EDGE_FLAG_DATA (GLboolean flag, void *udata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_VERTEX (void * vdata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_VERTEX_DATA (void * vdata, void * udata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_END (void);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_END_DATA (void * udata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_ERROR (GLenum errno);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_ERROR_DATA (GLenum errno, void * udata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_COMBINE (GLdouble coords[3], void *vdata[4],
+					   GLfloat weight[4], void **outdata);
+	LIBAPI void LIBAPIENTRY cbf_GLU_TESS_COMBINE_DATA (GLdouble coords[3], void *vdata[4],
+						GLfloat weight[4], void **outdata,
+						void *udata);
+
+	LIBAPI void LIBAPIENTRY cbf_GLU_ERROR (GLenum errno);
+
+#endif
diff --git a/CNativeCode/OpenGLU_JauJNI12_funcs.c b/CNativeCode/OpenGLU_JauJNI12_funcs.c
new file mode 100644
index 0000000..e7489ab
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNI12_funcs.c
@@ -0,0 +1,2354 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNI.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jint qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)qnt_obj, which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jint qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)qobj, which, 
+				           cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jint nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)nobj, which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jint tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jint qobj )
+{
+	gluDeleteQuadric((void *)qobj);
+	RemoveCallbackNodes((void *)qobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jint nobj )
+{
+	gluDeleteNurbsRenderer((void *)nobj);
+	RemoveCallbackNodes((void *)nobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jint tobj )
+{
+	gluDeleteTess((GLUtesselator *)tobj);
+	RemoveCallbackNodes((void *)tobj);
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLUFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, viewport, &isCopiedArray4);
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, viewport, 0);
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winx, &isCopiedArray6);
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winy, &isCopiedArray7);
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, winz, &isCopiedArray8);
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, viewport, 0);
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objx, &isCopiedArray6);
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objy, &isCopiedArray7);
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, objz, &isCopiedArray8);
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, datain, 0);
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, dataout, &isCopiedArray8);
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewQuadric (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewQuadric (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluSphere (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewNurbsRenderer (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewNurbsRenderer (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jfloat *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+		jint *ptr3 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, viewport, 0);
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, value, &isCopiedArray2);
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, knot, &isCopiedArray2);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ctlarray, &isCopiedArray4);
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, sknot, &isCopiedArray2);
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, tknot, &isCopiedArray4);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ctlarray, &isCopiedArray7);
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(array!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, array, &isCopiedArray2);
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewTess (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewTess (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, value, &isCopiedArray2);
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_JauJNI12tst_funcs.c b/CNativeCode/OpenGLU_JauJNI12tst_funcs.c
new file mode 100644
index 0000000..82c6f5d
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNI12tst_funcs.c
@@ -0,0 +1,2683 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNI.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jint qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)qnt_obj, which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jint qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)qobj, which, 
+				           cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jint nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)nobj, which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jint tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jint qobj )
+{
+	gluDeleteQuadric((void *)qobj);
+	RemoveCallbackNodes((void *)qobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jint nobj )
+{
+	gluDeleteNurbsRenderer((void *)nobj);
+	RemoveCallbackNodes((void *)nobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jint tobj )
+{
+	gluDeleteTess((GLUtesselator *)tobj);
+	RemoveCallbackNodes((void *)tobj);
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLUFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluPickMatrix arg: viewport");
+			}
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluProject arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluProject arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluProject arg: viewport");
+			}
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluProject arg: winx");
+			}
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluProject arg: winy");
+			}
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluProject arg: winz");
+			}
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluUnProject arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluUnProject arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluUnProject arg: viewport");
+			}
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluUnProject arg: objx");
+			}
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluUnProject arg: objy");
+			}
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluUnProject arg: objz");
+			}
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, datain, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluScaleImage arg: datain");
+			}
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluScaleImage arg: dataout");
+			}
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewQuadric (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewQuadric (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluSphere (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewNurbsRenderer (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewNurbsRenderer (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluLoadSamplingMatrices arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluLoadSamplingMatrices arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluLoadSamplingMatrices arg: viewport");
+			}
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluGetNurbsProperty arg: value");
+			}
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluNurbsCurve arg: knot");
+			}
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluNurbsCurve arg: ctlarray");
+			}
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluNurbsSurface arg: sknot");
+			}
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluNurbsSurface arg: tknot");
+			}
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluNurbsSurface arg: ctlarray");
+			}
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(array!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluPwlCurve arg: array");
+			}
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewTess (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewTess (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluGetTessProperty arg: value");
+			}
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_JauJNI_funcs.c b/CNativeCode/OpenGLU_JauJNI_funcs.c
new file mode 100644
index 0000000..32abe13
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNI_funcs.c
@@ -0,0 +1,2354 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNI.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jint qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)qnt_obj, which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jint qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)qobj, which, 
+				           cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jint nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)nobj, which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jint tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jint qobj )
+{
+	gluDeleteQuadric((void *)qobj);
+	RemoveCallbackNodes((void *)qobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jint nobj )
+{
+	gluDeleteNurbsRenderer((void *)nobj);
+	RemoveCallbackNodes((void *)nobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jint tobj )
+{
+	gluDeleteTess((GLUtesselator *)tobj);
+	RemoveCallbackNodes((void *)tobj);
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLUFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, datain, 0);
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewQuadric (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewQuadric (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluSphere (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewNurbsRenderer (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewNurbsRenderer (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jfloat *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+		jint *ptr3 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(array!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewTess (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewTess (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_JauJNInf_funcs.c b/CNativeCode/OpenGLU_JauJNInf_funcs.c
new file mode 100644
index 0000000..d37588d
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNInf_funcs.c
@@ -0,0 +1,2354 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNInf.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jint qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)qnt_obj, which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jint qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)qobj, which, 
+				           cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jint nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)nobj, which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jint tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jint qobj )
+{
+	gluDeleteQuadric((void *)qobj);
+	RemoveCallbackNodes((void *)qobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jint nobj )
+{
+	gluDeleteNurbsRenderer((void *)nobj);
+	RemoveCallbackNodes((void *)nobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jint tobj )
+{
+	gluDeleteTess((GLUtesselator *)tobj);
+	RemoveCallbackNodes((void *)tobj);
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLUFuncJauJNInf ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, datain, 0);
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNewQuadric (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewQuadric (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluSphere (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNewNurbsRenderer (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewNurbsRenderer (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jfloat *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+		jint *ptr3 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(array!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNewTess (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewTess (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__I_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__I_3D_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_JauJNItst_funcs.c b/CNativeCode/OpenGLU_JauJNItst_funcs.c
new file mode 100644
index 0000000..82c6f5d
--- /dev/null
+++ b/CNativeCode/OpenGLU_JauJNItst_funcs.c
@@ -0,0 +1,2683 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNI.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jint qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)qnt_obj, which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jint qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)qobj, which, 
+				           cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jint nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)nobj, which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jint tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)tobj, which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jint qobj )
+{
+	gluDeleteQuadric((void *)qobj);
+	RemoveCallbackNodes((void *)qobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jint nobj )
+{
+	gluDeleteNurbsRenderer((void *)nobj);
+	RemoveCallbackNodes((void *)nobj);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNI_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jint tobj )
+{
+	gluDeleteTess((GLUtesselator *)tobj);
+	RemoveCallbackNodes((void *)tobj);
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLUFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluPickMatrix arg: viewport");
+			}
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluProject arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluProject arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluProject arg: viewport");
+			}
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluProject arg: winx");
+			}
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluProject arg: winy");
+			}
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluProject arg: winz");
+			}
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluUnProject arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluUnProject arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluUnProject arg: viewport");
+			}
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluUnProject arg: objx");
+			}
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluUnProject arg: objy");
+			}
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluUnProject arg: objz");
+			}
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, datain, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluScaleImage arg: datain");
+			}
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by gluScaleImage arg: dataout");
+			}
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by gluBuild1DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, data, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by gluBuild2DMipmaps arg: data");
+			}
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUquadricObj * gluNewQuadric ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewQuadric (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewQuadric (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jint quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluSphere (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jint qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUnurbsObj * gluNewNurbsRenderer ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewNurbsRenderer (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewNurbsRenderer (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluLoadSamplingMatrices arg: modelMatrix");
+			}
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluLoadSamplingMatrices arg: projMatrix");
+			}
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by gluLoadSamplingMatrices arg: viewport");
+			}
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluGetNurbsProperty arg: value");
+			}
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluNurbsCurve arg: knot");
+			}
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluNurbsCurve arg: ctlarray");
+			}
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluNurbsSurface arg: sknot");
+			}
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by gluNurbsSurface arg: tknot");
+			}
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by gluNurbsSurface arg: ctlarray");
+			}
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jint nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jint nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(array!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluPwlCurve arg: array");
+			}
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLUtesselator * gluNewTess ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNewTess (
+		JNIEnv *env, jobject obj)
+	{
+		jint ret;
+
+
+		ret = (jint) gluNewTess (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginPolygon__I_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessBeginPolygon arg: polygon_data");
+			}
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3B (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3S (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3I (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3F (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessVertex__I_3D_3J (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by gluTessVertex arg: coords");
+			}
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluTessVertex arg: vertex_data");
+			}
+		}
+		gluTessVertex (
+			(GLUtesselator *) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by gluGetTessProperty arg: value");
+			}
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jint tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNI_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jint tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_funcs.c.skel b/CNativeCode/OpenGLU_funcs.c.skel
new file mode 100644
index 0000000..81cfda7
--- /dev/null
+++ b/CNativeCode/OpenGLU_funcs.c.skel
@@ -0,0 +1,55 @@
+/*

+ * Leo Chan -- 1995

+ *

+ * This C file takes care of all the native implementation for the

+ * OpenGL utility commands

+ * ---------------

+ *

+ * Sven Goethel

+ *

+ * September 1997

+ */

+

+/* 

+ * need to include the JAVA internal header files for macros and function

+ * prototypes required to maipulated JAVA data structures and functions

+ *

+ * StubPreamble.h includes the structure and macro definitions neede to

+ * convert JAVA data structures into C data structures.

+ *

+ */

+

+#ifdef _WIN32_

+ 	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <stdlib.h>

+

+#include <jni.h>

+

+/*

+ * the next thing to include are special headers that were created by

+ * JAVAH.  They include the C structure definitions for the JAVA classes

+ */

+#include "gl4java_GLUFuncJauJNI.h"

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+/*

+ * next put any specific header files that are necessary to implement

+ * this native code

+ */            

+#include<GL/gl.h>

+#include <GL/glu.h>

+

+#include "GLCallbackHelperJNI.h"

+#include "GLUCallbackJNI.h"

+#include "jnitools.h"

+

+/**

+ * herein lies the native JAVA methods for the OpenGL functions.  

+ */

+

diff --git a/CNativeCode/OpenGL_JauJNI12_dynfuncs.c b/CNativeCode/OpenGL_JauJNI12_dynfuncs.c
new file mode 100644
index 0000000..e0e7d43
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNI12_dynfuncs.c
@@ -0,0 +1,23658 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+    gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_glGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char * tmpString=0;
+
+    tmpString = glGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_gl_n_a_string;
+ 
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_version_);   
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearIndex ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearIndex (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glClearIndex", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glClearColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClear ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClear (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glClear", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIndexMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMask (
+		JNIEnv *env, jobject obj,
+		jboolean red,
+		jboolean green,
+		jboolean blue,
+		jboolean alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean, GLboolean, GLboolean, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean, GLboolean, GLboolean, GLboolean))
+				getGLProcAddressHelper("glColorMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) red,
+			(GLboolean) green,
+			(GLboolean) blue,
+			(GLboolean) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAlphaFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jfloat ref)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLclampf))
+				getGLProcAddressHelper("glAlphaFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLclampf) ref
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendFunc (
+		JNIEnv *env, jobject obj,
+		jint sfactor,
+		jint dfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glBlendFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) sfactor,
+			(GLenum) dfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLogicOp ( GLenum opcode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLogicOp (
+		JNIEnv *env, jobject obj,
+		jint opcode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glLogicOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) opcode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCullFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCullFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glCullFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrontFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrontFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glFrontFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointSize ( GLfloat size ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointSize (
+		JNIEnv *env, jobject obj,
+		jfloat size)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPointSize", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) size
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineWidth ( GLfloat width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineWidth (
+		JNIEnv *env, jobject obj,
+		jfloat width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glLineWidth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineStipple (
+		JNIEnv *env, jobject obj,
+		jint factor,
+		jshort pattern)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLushort))
+				getGLProcAddressHelper("glLineStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) factor,
+			(GLushort) pattern
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonMode (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glPolygonMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffset (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat units)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffset", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) units
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  mask, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte *))
+				getGLProcAddressHelper("glGetPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, &isCopiedArray0);
+		}
+		__func_ptr__ (
+			(GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlag (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glEdgeFlag", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagv (
+		JNIEnv *env, jobject obj,
+		jbooleanArray flag)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLboolean *) = NULL;
+		jboolean *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(flag!=NULL)
+		{
+			ptr0 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, flag, 0);
+		}
+		__func_ptr__ (
+			(const GLboolean *) ptr0
+		);
+
+		if(flag!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  flag, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScissor (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glScissor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, 0);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(const GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  equation, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDrawBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glReadBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsEnabled (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glIsEnabled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLenum) cap
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetBooleanv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean *))
+				getGLProcAddressHelper("glGetBooleanv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLboolean *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetDoublev (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetDoublev", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLdouble *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetFloatv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetFloatv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetIntegerv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint *))
+				getGLProcAddressHelper("glGetIntegerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushClientAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopClientAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopClientAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glRenderMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glRenderMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLenum) mode
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLenum glGetError ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetError (
+		JNIEnv *env, jobject obj)
+	{
+		static jint (CALLBACK *__func_ptr__)() = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)())
+				getGLProcAddressHelper("glGetError", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFinish ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFinish (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFinish", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFlush ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFlush (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFlush", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHint (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glHint", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearDepth ( GLclampd depth ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearDepth (
+		JNIEnv *env, jobject obj,
+		jdouble depth)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd))
+				getGLProcAddressHelper("glClearDepth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) depth
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthFunc ( GLenum func ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthFunc (
+		JNIEnv *env, jobject obj,
+		jint func)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDepthFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthMask ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthMask (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glDepthMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthRange (
+		JNIEnv *env, jobject obj,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd, GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd, GLclampd))
+				getGLProcAddressHelper("glDepthRange", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) near_val,
+			(GLclampd) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearAccum (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glClearAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAccum (
+		JNIEnv *env, jobject obj,
+		jint op,
+		jfloat value)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) op,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMatrixMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMatrixMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glMatrixMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glOrtho (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glOrtho", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrustum (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glFrustum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glViewport (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glViewport", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPushMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadIdentity ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadIdentity (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glLoadIdentity", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glLoadMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glLoadMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glMultMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glMultMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotated (
+		JNIEnv *env, jobject obj,
+		jdouble angle,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRotated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) angle,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotatef (
+		JNIEnv *env, jobject obj,
+		jfloat angle,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRotatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) angle,
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScaled (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glScaled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScalef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glScalef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslated (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTranslated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslatef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTranslatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) list
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteLists (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint range)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLsizei))
+				getGLProcAddressHelper("glDeleteLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLsizei) range
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenLists (
+		JNIEnv *env, jobject obj,
+		jint range)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLsizei) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLsizei))
+				getGLProcAddressHelper("glGenLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLsizei) range
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNewList (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLenum))
+				getGLProcAddressHelper("glNewList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEndList ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEndList (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEndList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glCallList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3B (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbyteArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3S (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jshortArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3I (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jintArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3F (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jfloatArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3D (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jdoubleArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbooleanArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3J (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jlongArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glListBase ( GLuint base ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glListBase (
+		JNIEnv *env, jobject obj,
+		jint base)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glListBase", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) base
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBegin ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBegin (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBegin", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnd ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnd (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEnd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glVertex2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glVertex2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3b (
+		JNIEnv *env, jobject obj,
+		jbyte nx,
+		jbyte ny,
+		jbyte nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glNormal3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) nx,
+			(GLbyte) ny,
+			(GLbyte) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3d (
+		JNIEnv *env, jobject obj,
+		jdouble nx,
+		jdouble ny,
+		jdouble nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glNormal3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) nx,
+			(GLdouble) ny,
+			(GLdouble) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3f (
+		JNIEnv *env, jobject obj,
+		jfloat nx,
+		jfloat ny,
+		jfloat nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glNormal3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) nx,
+			(GLfloat) ny,
+			(GLfloat) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3i (
+		JNIEnv *env, jobject obj,
+		jint nx,
+		jint ny,
+		jint nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glNormal3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) nx,
+			(GLint) ny,
+			(GLint) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3s (
+		JNIEnv *env, jobject obj,
+		jshort nx,
+		jshort ny,
+		jshort nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glNormal3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) nx,
+			(GLshort) ny,
+			(GLshort) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glNormal3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glNormal3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glNormal3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glNormal3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glNormal3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexd ( GLdouble c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexd (
+		JNIEnv *env, jobject obj,
+		jdouble c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glIndexd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexf ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexf (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glIndexf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexi ( GLint c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexi (
+		JNIEnv *env, jobject obj,
+		jint c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glIndexi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexs ( GLshort c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexs (
+		JNIEnv *env, jobject obj,
+		jshort c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glIndexs", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexub ( GLubyte c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexub (
+		JNIEnv *env, jobject obj,
+		jbyte c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte))
+				getGLProcAddressHelper("glIndexub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glIndexdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glIndexfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexiv ( const GLint * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexiv (
+		JNIEnv *env, jobject obj,
+		jintArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glIndexiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexsv ( const GLshort * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexsv (
+		JNIEnv *env, jobject obj,
+		jshortArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glIndexsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glIndexubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor3ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor3ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor3us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor4b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue,
+			(GLbyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue,
+		jdouble alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue,
+			(GLdouble) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue,
+			(GLint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue,
+			(GLshort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor4ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue,
+			(GLubyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor4ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue,
+			(GLuint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor4us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue,
+			(GLushort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor3ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor3uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor3usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor4bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor4ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor4uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor4usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glTexCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glTexCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1i ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1i (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glTexCoord1i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1s ( GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1s (
+		JNIEnv *env, jobject obj,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glTexCoord1s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glTexCoord2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord1iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord1sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glRasterPos2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectd (
+		JNIEnv *env, jobject obj,
+		jdouble x1,
+		jdouble y1,
+		jdouble x2,
+		jdouble y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRectd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x1,
+			(GLdouble) y1,
+			(GLdouble) x2,
+			(GLdouble) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectf (
+		JNIEnv *env, jobject obj,
+		jfloat x1,
+		jfloat y1,
+		jfloat x2,
+		jfloat y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRectf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x1,
+			(GLfloat) y1,
+			(GLfloat) x2,
+			(GLfloat) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRecti (
+		JNIEnv *env, jobject obj,
+		jint x1,
+		jint y1,
+		jint x2,
+		jint y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRecti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x1,
+			(GLint) y1,
+			(GLint) x2,
+			(GLint) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRects (
+		JNIEnv *env, jobject obj,
+		jshort x1,
+		jshort y1,
+		jshort x2,
+		jshort y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRects", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x1,
+			(GLshort) y1,
+			(GLshort) x2,
+			(GLshort) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v1,
+		jdoubleArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *, const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *, const GLdouble *))
+				getGLProcAddressHelper("glRectdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0,
+			(const GLdouble *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v1,
+		jfloatArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *, const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *, const GLfloat *))
+				getGLProcAddressHelper("glRectfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0,
+			(const GLfloat *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectiv (
+		JNIEnv *env, jobject obj,
+		jintArray v1,
+		jintArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *, const GLint *) = NULL;
+		jint *ptr0 = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *, const GLint *))
+				getGLProcAddressHelper("glRectiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0,
+			(const GLint *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectsv (
+		JNIEnv *env, jobject obj,
+		jshortArray v1,
+		jshortArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *, const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *, const GLshort *))
+				getGLProcAddressHelper("glRectsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0,
+			(const GLshort *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3B (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3S (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3I (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3F (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3D (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3J (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElement ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElement (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElement", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArrays (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbyteArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3S (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jshortArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3I (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jintArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3F (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jfloatArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3D (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jdoubleArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbooleanArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3J (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jlongArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glShadeModel ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glShadeModel (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glShadeModel", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightf (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glLightf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLighti (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glLighti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glLightModelf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeli (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glLightModeli", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightModelfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeliv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glLightModeliv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialf (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glMaterialf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMateriali (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glMateriali", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMaterial (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glColorMaterial", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelZoom (
+		JNIEnv *env, jobject obj,
+		jfloat xfactor,
+		jfloat yfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPixelZoom", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) xfactor,
+			(GLfloat) yfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStoref (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelStoref", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStorei (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelStorei", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelTransferf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelTransferi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLfloat *))
+				getGLProcAddressHelper("glPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLfloat *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLuint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLuint *))
+				getGLProcAddressHelper("glPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLuint *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLushort *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLushort *))
+				getGLProcAddressHelper("glPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLushort *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLfloat *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint *))
+				getGLProcAddressHelper("glGetPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLuint *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLushort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLushort *))
+				getGLProcAddressHelper("glGetPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLushort *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBitmap (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jfloat xorig,
+		jfloat yorig,
+		jfloat xmove,
+		jfloat ymove,
+		jbyteArray bitmap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))
+				getGLProcAddressHelper("glBitmap", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(bitmap!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, bitmap, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLfloat) xorig,
+			(GLfloat) yorig,
+			(GLfloat) xmove,
+			(GLfloat) ymove,
+			(const GLubyte *) ptr6
+		);
+
+		if(bitmap!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  bitmap, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyPixels (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint type)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum))
+				getGLProcAddressHelper("glCopyPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jint ref,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLuint))
+				getGLProcAddressHelper("glStencilFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLint) ref,
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glStencilMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilOp (
+		JNIEnv *env, jobject obj,
+		jint fail,
+		jint zfail,
+		jint zpass)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum))
+				getGLProcAddressHelper("glStencilOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) fail,
+			(GLenum) zfail,
+			(GLenum) zpass
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearStencil ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearStencil (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glClearStencil", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGend (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdouble param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble))
+				getGLProcAddressHelper("glTexGend", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenf (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexGenf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeni (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexGeni", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLdouble *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLdouble *))
+				getGLProcAddressHelper("glTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexEnvf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvi (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexEnvi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexLevelParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLfloat *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexLevelParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLint *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTexture (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResident (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResident", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTexture (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint stride,
+		jint order,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLdouble *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint stride,
+		jint order,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLfloat *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint ustride,
+		jint uorder,
+		jdouble v1,
+		jdouble v2,
+		jint vstride,
+		jint vorder,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLdouble) v1,
+			(GLdouble) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLdouble *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint ustride,
+		jint uorder,
+		jfloat v1,
+		jfloat v2,
+		jint vstride,
+		jint vorder,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLfloat) v1,
+			(GLfloat) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLfloat *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapdv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetMapdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLdouble *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLfloat *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapiv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMapiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLint *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glEvalCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glEvalCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble u,
+		jdouble v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glEvalCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u,
+			(GLdouble) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat u,
+		jfloat v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glEvalCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u,
+			(GLfloat) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2,
+		jint vn,
+		jdouble v1,
+		jdouble v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) vn,
+			(GLdouble) v1,
+			(GLdouble) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2,
+		jint vn,
+		jfloat v1,
+		jfloat v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) vn,
+			(GLfloat) v1,
+			(GLfloat) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint1 ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint1 (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glEvalPoint1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint2 (
+		JNIEnv *env, jobject obj,
+		jint i,
+		jint j)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glEvalPoint2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i,
+			(GLint) j
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh1 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh2 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2,
+		jint j1,
+		jint j2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2,
+			(GLint) j1,
+			(GLint) j2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glFogf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glFogi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glFogfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogiv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glFogiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFeedbackBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jfloatArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, GLfloat *))
+				getGLProcAddressHelper("glFeedbackBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLenum) type,
+			(GLfloat *) ptr2
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPassThrough ( GLfloat token ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPassThrough (
+		JNIEnv *env, jobject obj,
+		jfloat token)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPassThrough", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) token
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSelectBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jintArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glSelectBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLuint *) ptr1
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInitNames ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInitNames (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glInitNames", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glLoadName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glPushName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopName ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopName (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorSubTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquation ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquation (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquation", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHistogram (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint width,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, GLboolean))
+				getGLProcAddressHelper("glHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) width,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetHistogram ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetHistogram (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetHistogramParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetHistogramParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMinmax (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLboolean))
+				getGLProcAddressHelper("glMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetMinmax ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetMinmax (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMinmaxParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMinmaxParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glConvolutionParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glConvolutionParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3B_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column,
+		jbyteArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3S_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column,
+		jshortArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3I_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column,
+		jintArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3F_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column,
+		jfloatArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3D_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column,
+		jdoubleArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3Z_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column,
+		jbooleanArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3J_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column,
+		jlongArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColorEXT (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColorEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffsetEXT (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat bias)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffsetEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) bias
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3DEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResidentEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResidentEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointerEXT (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, const GLboolean *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLboolean *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElementEXT ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElementEXT (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElementEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquationEXT (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquationEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPointParameterfEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glPointParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterivEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameterivEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLockArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLsizei))
+				getGLProcAddressHelper("glLockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glUnlockArraysEXT ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glUnlockArraysEXT (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glUnlockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClientActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glClientActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord1dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord1dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord1fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord1fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glMultiTexCoord1iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord1ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord1sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord1svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord2dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord2dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord2fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord2fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord2iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord2ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord2sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord2svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord3dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord3dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord3fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord3fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord3iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord3ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord3sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord3svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord4dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord4dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord4fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord4fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord4iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord4ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord4sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord4svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGL_JauJNI12tst_dynfuncs.c b/CNativeCode/OpenGL_JauJNI12tst_dynfuncs.c
new file mode 100644
index 0000000..c47667c
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNI12tst_dynfuncs.c
@@ -0,0 +1,26455 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+    gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_glGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char * tmpString=0;
+
+    tmpString = glGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_gl_n_a_string;
+ 
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_version_);   
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearIndex ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearIndex (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glClearIndex", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glClearColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClear ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClear (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glClear", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIndexMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMask (
+		JNIEnv *env, jobject obj,
+		jboolean red,
+		jboolean green,
+		jboolean blue,
+		jboolean alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean, GLboolean, GLboolean, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean, GLboolean, GLboolean, GLboolean))
+				getGLProcAddressHelper("glColorMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) red,
+			(GLboolean) green,
+			(GLboolean) blue,
+			(GLboolean) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAlphaFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jfloat ref)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLclampf))
+				getGLProcAddressHelper("glAlphaFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLclampf) ref
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendFunc (
+		JNIEnv *env, jobject obj,
+		jint sfactor,
+		jint dfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glBlendFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) sfactor,
+			(GLenum) dfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLogicOp ( GLenum opcode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLogicOp (
+		JNIEnv *env, jobject obj,
+		jint opcode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glLogicOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) opcode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCullFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCullFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glCullFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrontFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrontFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glFrontFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointSize ( GLfloat size ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointSize (
+		JNIEnv *env, jobject obj,
+		jfloat size)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPointSize", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) size
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineWidth ( GLfloat width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineWidth (
+		JNIEnv *env, jobject obj,
+		jfloat width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glLineWidth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineStipple (
+		JNIEnv *env, jobject obj,
+		jint factor,
+		jshort pattern)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLushort))
+				getGLProcAddressHelper("glLineStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) factor,
+			(GLushort) pattern
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonMode (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glPolygonMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffset (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat units)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffset", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) units
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glPolygonStipple arg: mask");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  mask, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte *))
+				getGLProcAddressHelper("glGetPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, mask, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glGetPolygonStipple arg: mask");
+			}
+		}
+		__func_ptr__ (
+			(GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlag (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glEdgeFlag", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagv (
+		JNIEnv *env, jobject obj,
+		jbooleanArray flag)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLboolean *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jboolean *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(flag!=NULL)
+		{
+			ptr0 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, flag, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEdgeFlagv arg: flag");
+			}
+		}
+		__func_ptr__ (
+			(const GLboolean *) ptr0
+		);
+
+		if(flag!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  flag, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScissor (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glScissor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glClipPlane arg: equation");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(const GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  equation, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, equation, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetClipPlane arg: equation");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDrawBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glReadBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsEnabled (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glIsEnabled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLenum) cap
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetBooleanv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean *))
+				getGLProcAddressHelper("glGetBooleanv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetBooleanv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLboolean *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetDoublev (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetDoublev", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetDoublev arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLdouble *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetFloatv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetFloatv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetFloatv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetIntegerv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint *))
+				getGLProcAddressHelper("glGetIntegerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetIntegerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushClientAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopClientAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopClientAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glRenderMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glRenderMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLenum) mode
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLenum glGetError ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetError (
+		JNIEnv *env, jobject obj)
+	{
+		static jint (CALLBACK *__func_ptr__)() = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)())
+				getGLProcAddressHelper("glGetError", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFinish ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFinish (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFinish", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFlush ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFlush (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFlush", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHint (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glHint", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearDepth ( GLclampd depth ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearDepth (
+		JNIEnv *env, jobject obj,
+		jdouble depth)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd))
+				getGLProcAddressHelper("glClearDepth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) depth
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthFunc ( GLenum func ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthFunc (
+		JNIEnv *env, jobject obj,
+		jint func)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDepthFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthMask ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthMask (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glDepthMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthRange (
+		JNIEnv *env, jobject obj,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd, GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd, GLclampd))
+				getGLProcAddressHelper("glDepthRange", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) near_val,
+			(GLclampd) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearAccum (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glClearAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAccum (
+		JNIEnv *env, jobject obj,
+		jint op,
+		jfloat value)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) op,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMatrixMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMatrixMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glMatrixMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glOrtho (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glOrtho", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrustum (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glFrustum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glViewport (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glViewport", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPushMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadIdentity ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadIdentity (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glLoadIdentity", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glLoadMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glLoadMatrixd arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glLoadMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glLoadMatrixf arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glMultMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glMultMatrixd arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glMultMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glMultMatrixf arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotated (
+		JNIEnv *env, jobject obj,
+		jdouble angle,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRotated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) angle,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotatef (
+		JNIEnv *env, jobject obj,
+		jfloat angle,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRotatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) angle,
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScaled (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glScaled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScalef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glScalef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslated (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTranslated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslatef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTranslatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) list
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteLists (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint range)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLsizei))
+				getGLProcAddressHelper("glDeleteLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLsizei) range
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenLists (
+		JNIEnv *env, jobject obj,
+		jint range)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLsizei) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLsizei))
+				getGLProcAddressHelper("glGenLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLsizei) range
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNewList (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLenum))
+				getGLProcAddressHelper("glNewList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEndList ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEndList (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEndList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glCallList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3B (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbyteArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3S (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jshortArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3I (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jintArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3F (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jfloatArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3D (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jdoubleArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbooleanArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3J (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jlongArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glListBase ( GLuint base ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glListBase (
+		JNIEnv *env, jobject obj,
+		jint base)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glListBase", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) base
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBegin ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBegin (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBegin", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnd ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnd (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEnd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glVertex2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glVertex2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3b (
+		JNIEnv *env, jobject obj,
+		jbyte nx,
+		jbyte ny,
+		jbyte nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glNormal3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) nx,
+			(GLbyte) ny,
+			(GLbyte) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3d (
+		JNIEnv *env, jobject obj,
+		jdouble nx,
+		jdouble ny,
+		jdouble nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glNormal3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) nx,
+			(GLdouble) ny,
+			(GLdouble) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3f (
+		JNIEnv *env, jobject obj,
+		jfloat nx,
+		jfloat ny,
+		jfloat nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glNormal3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) nx,
+			(GLfloat) ny,
+			(GLfloat) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3i (
+		JNIEnv *env, jobject obj,
+		jint nx,
+		jint ny,
+		jint nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glNormal3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) nx,
+			(GLint) ny,
+			(GLint) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3s (
+		JNIEnv *env, jobject obj,
+		jshort nx,
+		jshort ny,
+		jshort nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glNormal3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) nx,
+			(GLshort) ny,
+			(GLshort) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glNormal3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glNormal3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glNormal3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glNormal3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glNormal3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexd ( GLdouble c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexd (
+		JNIEnv *env, jobject obj,
+		jdouble c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glIndexd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexf ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexf (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glIndexf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexi ( GLint c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexi (
+		JNIEnv *env, jobject obj,
+		jint c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glIndexi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexs ( GLshort c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexs (
+		JNIEnv *env, jobject obj,
+		jshort c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glIndexs", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexub ( GLubyte c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexub (
+		JNIEnv *env, jobject obj,
+		jbyte c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte))
+				getGLProcAddressHelper("glIndexub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glIndexdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexdv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glIndexfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexfv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexiv ( const GLint * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexiv (
+		JNIEnv *env, jobject obj,
+		jintArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glIndexiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexiv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexsv ( const GLshort * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexsv (
+		JNIEnv *env, jobject obj,
+		jshortArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glIndexsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexsv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glIndexubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexubv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor3ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor3ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor3us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor4b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue,
+			(GLbyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue,
+		jdouble alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue,
+			(GLdouble) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue,
+			(GLint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue,
+			(GLshort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor4ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue,
+			(GLubyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor4ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue,
+			(GLuint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor4us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue,
+			(GLushort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor3ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3ubv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor3uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3uiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor3usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3usv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor4bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor4ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4ubv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor4uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4uiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor4usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4usv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glTexCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glTexCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1i ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1i (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glTexCoord1i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1s ( GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1s (
+		JNIEnv *env, jobject obj,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glTexCoord1s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glTexCoord2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord1iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord1sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glRasterPos2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectd (
+		JNIEnv *env, jobject obj,
+		jdouble x1,
+		jdouble y1,
+		jdouble x2,
+		jdouble y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRectd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x1,
+			(GLdouble) y1,
+			(GLdouble) x2,
+			(GLdouble) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectf (
+		JNIEnv *env, jobject obj,
+		jfloat x1,
+		jfloat y1,
+		jfloat x2,
+		jfloat y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRectf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x1,
+			(GLfloat) y1,
+			(GLfloat) x2,
+			(GLfloat) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRecti (
+		JNIEnv *env, jobject obj,
+		jint x1,
+		jint y1,
+		jint x2,
+		jint y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRecti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x1,
+			(GLint) y1,
+			(GLint) x2,
+			(GLint) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRects (
+		JNIEnv *env, jobject obj,
+		jshort x1,
+		jshort y1,
+		jshort x2,
+		jshort y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRects", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x1,
+			(GLshort) y1,
+			(GLshort) x2,
+			(GLshort) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v1,
+		jdoubleArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *, const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *, const GLdouble *))
+				getGLProcAddressHelper("glRectdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectdv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectdv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0,
+			(const GLdouble *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v1,
+		jfloatArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *, const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *, const GLfloat *))
+				getGLProcAddressHelper("glRectfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectfv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectfv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0,
+			(const GLfloat *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectiv (
+		JNIEnv *env, jobject obj,
+		jintArray v1,
+		jintArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *, const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *, const GLint *))
+				getGLProcAddressHelper("glRectiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectiv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectiv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0,
+			(const GLint *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectsv (
+		JNIEnv *env, jobject obj,
+		jshortArray v1,
+		jshortArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *, const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *, const GLshort *))
+				getGLProcAddressHelper("glRectsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectsv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectsv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0,
+			(const GLshort *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3B (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3S (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3I (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3F (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3D (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3J (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElement ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElement (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElement", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArrays (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbyteArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3S (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jshortArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3I (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jintArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3F (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jfloatArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3D (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jdoubleArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbooleanArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3J (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jlongArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glShadeModel ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glShadeModel (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glShadeModel", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightf (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glLightf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLighti (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glLighti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glLightfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glLightiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetLightfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetLightiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glLightModelf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeli (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glLightModeli", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightModelfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glLightModelfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeliv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glLightModeliv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glLightModeliv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialf (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glMaterialf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMateriali (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glMateriali", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glMaterialfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glMaterialiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMaterialfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMaterialiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMaterial (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glColorMaterial", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelZoom (
+		JNIEnv *env, jobject obj,
+		jfloat xfactor,
+		jfloat yfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPixelZoom", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) xfactor,
+			(GLfloat) yfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStoref (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelStoref", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStorei (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelStorei", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelTransferf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelTransferi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLfloat *))
+				getGLProcAddressHelper("glPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapfv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLfloat *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLuint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLuint *))
+				getGLProcAddressHelper("glPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapuiv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLuint *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLushort *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLushort *))
+				getGLProcAddressHelper("glPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapusv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLushort *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapfv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLfloat *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint *))
+				getGLProcAddressHelper("glGetPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapuiv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLuint *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLushort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLushort *))
+				getGLProcAddressHelper("glGetPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapusv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLushort *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBitmap (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jfloat xorig,
+		jfloat yorig,
+		jfloat xmove,
+		jfloat ymove,
+		jbyteArray bitmap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))
+				getGLProcAddressHelper("glBitmap", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(bitmap!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, bitmap, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glBitmap arg: bitmap");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLfloat) xorig,
+			(GLfloat) yorig,
+			(GLfloat) xmove,
+			(GLfloat) ymove,
+			(const GLubyte *) ptr6
+		);
+
+		if(bitmap!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  bitmap, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyPixels (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint type)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum))
+				getGLProcAddressHelper("glCopyPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jint ref,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLuint))
+				getGLProcAddressHelper("glStencilFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLint) ref,
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glStencilMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilOp (
+		JNIEnv *env, jobject obj,
+		jint fail,
+		jint zfail,
+		jint zpass)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum))
+				getGLProcAddressHelper("glStencilOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) fail,
+			(GLenum) zfail,
+			(GLenum) zpass
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearStencil ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearStencil (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glClearStencil", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGend (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdouble param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble))
+				getGLProcAddressHelper("glTexGend", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenf (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexGenf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeni (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexGeni", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLdouble *))
+				getGLProcAddressHelper("glTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGendv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGenfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGeniv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGendv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGenfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGeniv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexEnvf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvi (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexEnvi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexEnvfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexEnviv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexEnvfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexEnviv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexLevelParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetTexLevelParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLfloat *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexLevelParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetTexLevelParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLint *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jbyte *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jshort *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jint *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jboolean *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jlong *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jshort *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jint *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jfloat *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jboolean *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jlong *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGenTextures arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glDeleteTextures arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTexture (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPrioritizeTextures arg: textures");
+			}
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPrioritizeTextures arg: priorities");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResident (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResident", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glAreTexturesResident arg: textures");
+			}
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glAreTexturesResident arg: residences");
+			}
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTexture (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jshort *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jint *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jfloat *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jboolean *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jlong *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint stride,
+		jint order,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glMap1d arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLdouble *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint stride,
+		jint order,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glMap1f arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLfloat *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint ustride,
+		jint uorder,
+		jdouble v1,
+		jdouble v2,
+		jint vstride,
+		jint vorder,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, points, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glMap2d arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLdouble) v1,
+			(GLdouble) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLdouble *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint ustride,
+		jint uorder,
+		jfloat v1,
+		jfloat v2,
+		jint vstride,
+		jint vorder,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, points, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glMap2f arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLfloat) v1,
+			(GLfloat) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLfloat *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapdv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetMapdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapdv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLdouble *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapfv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLfloat *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapiv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMapiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLint *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glEvalCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glEvalCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord1dv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord1fv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble u,
+		jdouble v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glEvalCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u,
+			(GLdouble) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat u,
+		jfloat v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glEvalCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u,
+			(GLfloat) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord2dv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord2fv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2,
+		jint vn,
+		jdouble v1,
+		jdouble v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) vn,
+			(GLdouble) v1,
+			(GLdouble) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2,
+		jint vn,
+		jfloat v1,
+		jfloat v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) vn,
+			(GLfloat) v1,
+			(GLfloat) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint1 ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint1 (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glEvalPoint1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint2 (
+		JNIEnv *env, jobject obj,
+		jint i,
+		jint j)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glEvalPoint2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i,
+			(GLint) j
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh1 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh2 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2,
+		jint j1,
+		jint j2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2,
+			(GLint) j1,
+			(GLint) j2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glFogf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glFogi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glFogfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glFogfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogiv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glFogiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glFogiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFeedbackBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jfloatArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, GLfloat *))
+				getGLProcAddressHelper("glFeedbackBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glFeedbackBuffer arg: buffer");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLenum) type,
+			(GLfloat *) ptr2
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPassThrough ( GLfloat token ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPassThrough (
+		JNIEnv *env, jobject obj,
+		jfloat token)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPassThrough", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) token
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSelectBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jintArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glSelectBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, buffer, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glSelectBuffer arg: buffer");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLuint *) ptr1
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInitNames ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInitNames (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glInitNames", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glLoadName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glPushName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopName ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopName (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jbyte *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jshort *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jint *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jboolean *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jlong *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jbyte *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jshort *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jint *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jfloat *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jdouble *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jboolean *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jlong *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glColorTableParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glColorTableParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorSubTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquation ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquation (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquation", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHistogram (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint width,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, GLboolean))
+				getGLProcAddressHelper("glHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) width,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetHistogram ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetHistogram (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetHistogramParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetHistogramParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetHistogramParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetHistogramParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMinmax (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLboolean))
+				getGLProcAddressHelper("glMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetMinmax ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetMinmax (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMinmaxParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMinmaxParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMinmaxParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMinmaxParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glConvolutionParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glConvolutionParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glConvolutionParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glConvolutionParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetConvolutionParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetConvolutionParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jbyte *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jshort *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jint *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jboolean *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jlong *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3B_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column,
+		jbyteArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3S_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column,
+		jshortArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3I_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column,
+		jintArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3F_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column,
+		jfloatArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3D_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column,
+		jdoubleArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3Z_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column,
+		jbooleanArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3J_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column,
+		jlongArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColorEXT (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColorEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffsetEXT (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat bias)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffsetEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) bias
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jbyte *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jshort *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jint *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jboolean *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jlong *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jbyte *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jshort *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jint *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jint *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jfloat *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jdouble *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jboolean *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jlong *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3DEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGenTexturesEXT arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glDeleteTexturesEXT arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPrioritizeTexturesEXT arg: textures");
+			}
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, priorities, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPrioritizeTexturesEXT arg: priorities");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResidentEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResidentEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glAreTexturesResidentEXT arg: textures");
+			}
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, residences, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glAreTexturesResidentEXT arg: residences");
+			}
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jint *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointerEXT (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, const GLboolean *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glEdgeFlagPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLboolean *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElementEXT ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElementEXT (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElementEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquationEXT (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquationEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPointParameterfEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glPointParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPointParameterfvEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jint *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jbyte *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jint *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jboolean *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (jlong *) (*env)->GetPrimitiveArrayCritical(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterfvEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterivEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameterivEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (jint *) (*env)->GetPrimitiveArrayCritical(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterivEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLockArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLsizei))
+				getGLProcAddressHelper("glLockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glUnlockArraysEXT ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glUnlockArraysEXT (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glUnlockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClientActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glClientActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord1dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord1dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord1fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord1fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glMultiTexCoord1iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord1ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord1sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord1svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord2dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord2dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord2fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord2fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord2iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord2ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord2sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord2svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord3dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord3dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord3fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord3fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord3iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord3ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord3sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord3svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord4dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord4dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jdouble *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord4fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord4fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jfloat *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord4iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord4ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jint *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord4sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord4svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (jshort *) (*env)->GetPrimitiveArrayCritical(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleasePrimitiveArrayCritical(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGL_JauJNI_dynfuncs.c b/CNativeCode/OpenGL_JauJNI_dynfuncs.c
new file mode 100644
index 0000000..534d61e
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNI_dynfuncs.c
@@ -0,0 +1,23658 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+    gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_glGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char * tmpString=0;
+
+    tmpString = glGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_gl_n_a_string;
+ 
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_version_);   
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearIndex ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearIndex (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glClearIndex", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glClearColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClear ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClear (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glClear", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIndexMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMask (
+		JNIEnv *env, jobject obj,
+		jboolean red,
+		jboolean green,
+		jboolean blue,
+		jboolean alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean, GLboolean, GLboolean, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean, GLboolean, GLboolean, GLboolean))
+				getGLProcAddressHelper("glColorMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) red,
+			(GLboolean) green,
+			(GLboolean) blue,
+			(GLboolean) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAlphaFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jfloat ref)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLclampf))
+				getGLProcAddressHelper("glAlphaFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLclampf) ref
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendFunc (
+		JNIEnv *env, jobject obj,
+		jint sfactor,
+		jint dfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glBlendFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) sfactor,
+			(GLenum) dfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLogicOp ( GLenum opcode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLogicOp (
+		JNIEnv *env, jobject obj,
+		jint opcode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glLogicOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) opcode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCullFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCullFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glCullFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrontFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrontFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glFrontFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointSize ( GLfloat size ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointSize (
+		JNIEnv *env, jobject obj,
+		jfloat size)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPointSize", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) size
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineWidth ( GLfloat width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineWidth (
+		JNIEnv *env, jobject obj,
+		jfloat width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glLineWidth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineStipple (
+		JNIEnv *env, jobject obj,
+		jint factor,
+		jshort pattern)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLushort))
+				getGLProcAddressHelper("glLineStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) factor,
+			(GLushort) pattern
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonMode (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glPolygonMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffset (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat units)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffset", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) units
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte *))
+				getGLProcAddressHelper("glGetPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, &isCopiedArray0);
+		}
+		__func_ptr__ (
+			(GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlag (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glEdgeFlag", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagv (
+		JNIEnv *env, jobject obj,
+		jbooleanArray flag)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLboolean *) = NULL;
+		jboolean *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(flag!=NULL)
+		{
+			ptr0 = (*env)->GetBooleanArrayElements(env, flag, 0);
+		}
+		__func_ptr__ (
+			(const GLboolean *) ptr0
+		);
+
+		if(flag!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  flag, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScissor (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glScissor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, 0);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(const GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDrawBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glReadBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsEnabled (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glIsEnabled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLenum) cap
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetBooleanv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean *))
+				getGLProcAddressHelper("glGetBooleanv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLboolean *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetDoublev (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetDoublev", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLdouble *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetFloatv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetFloatv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetIntegerv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint *))
+				getGLProcAddressHelper("glGetIntegerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushClientAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopClientAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopClientAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glRenderMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glRenderMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLenum) mode
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLenum glGetError ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetError (
+		JNIEnv *env, jobject obj)
+	{
+		static jint (CALLBACK *__func_ptr__)() = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)())
+				getGLProcAddressHelper("glGetError", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFinish ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFinish (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFinish", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFlush ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFlush (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFlush", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHint (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glHint", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearDepth ( GLclampd depth ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearDepth (
+		JNIEnv *env, jobject obj,
+		jdouble depth)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd))
+				getGLProcAddressHelper("glClearDepth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) depth
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthFunc ( GLenum func ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthFunc (
+		JNIEnv *env, jobject obj,
+		jint func)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDepthFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthMask ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthMask (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glDepthMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthRange (
+		JNIEnv *env, jobject obj,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd, GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd, GLclampd))
+				getGLProcAddressHelper("glDepthRange", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) near_val,
+			(GLclampd) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearAccum (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glClearAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAccum (
+		JNIEnv *env, jobject obj,
+		jint op,
+		jfloat value)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) op,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMatrixMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMatrixMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glMatrixMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glOrtho (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glOrtho", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrustum (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glFrustum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glViewport (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glViewport", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPushMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadIdentity ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadIdentity (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glLoadIdentity", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glLoadMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glLoadMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glMultMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glMultMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotated (
+		JNIEnv *env, jobject obj,
+		jdouble angle,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRotated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) angle,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotatef (
+		JNIEnv *env, jobject obj,
+		jfloat angle,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRotatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) angle,
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScaled (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glScaled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScalef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glScalef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslated (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTranslated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslatef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTranslatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) list
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteLists (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint range)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLsizei))
+				getGLProcAddressHelper("glDeleteLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLsizei) range
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenLists (
+		JNIEnv *env, jobject obj,
+		jint range)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLsizei) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLsizei))
+				getGLProcAddressHelper("glGenLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLsizei) range
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNewList (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLenum))
+				getGLProcAddressHelper("glNewList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEndList ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEndList (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEndList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glCallList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3B (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbyteArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3S (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jshortArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3I (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jintArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3F (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jfloatArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3D (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jdoubleArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbooleanArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3J (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jlongArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glListBase ( GLuint base ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glListBase (
+		JNIEnv *env, jobject obj,
+		jint base)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glListBase", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) base
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBegin ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBegin (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBegin", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnd ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnd (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEnd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glVertex2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glVertex2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3b (
+		JNIEnv *env, jobject obj,
+		jbyte nx,
+		jbyte ny,
+		jbyte nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glNormal3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) nx,
+			(GLbyte) ny,
+			(GLbyte) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3d (
+		JNIEnv *env, jobject obj,
+		jdouble nx,
+		jdouble ny,
+		jdouble nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glNormal3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) nx,
+			(GLdouble) ny,
+			(GLdouble) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3f (
+		JNIEnv *env, jobject obj,
+		jfloat nx,
+		jfloat ny,
+		jfloat nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glNormal3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) nx,
+			(GLfloat) ny,
+			(GLfloat) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3i (
+		JNIEnv *env, jobject obj,
+		jint nx,
+		jint ny,
+		jint nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glNormal3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) nx,
+			(GLint) ny,
+			(GLint) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3s (
+		JNIEnv *env, jobject obj,
+		jshort nx,
+		jshort ny,
+		jshort nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glNormal3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) nx,
+			(GLshort) ny,
+			(GLshort) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glNormal3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glNormal3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glNormal3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glNormal3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glNormal3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexd ( GLdouble c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexd (
+		JNIEnv *env, jobject obj,
+		jdouble c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glIndexd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexf ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexf (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glIndexf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexi ( GLint c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexi (
+		JNIEnv *env, jobject obj,
+		jint c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glIndexi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexs ( GLshort c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexs (
+		JNIEnv *env, jobject obj,
+		jshort c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glIndexs", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexub ( GLubyte c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexub (
+		JNIEnv *env, jobject obj,
+		jbyte c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte))
+				getGLProcAddressHelper("glIndexub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glIndexdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glIndexfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexiv ( const GLint * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexiv (
+		JNIEnv *env, jobject obj,
+		jintArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glIndexiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexsv ( const GLshort * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexsv (
+		JNIEnv *env, jobject obj,
+		jshortArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glIndexsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glIndexubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor3ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor3ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor3us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor4b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue,
+			(GLbyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue,
+		jdouble alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue,
+			(GLdouble) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue,
+			(GLint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue,
+			(GLshort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor4ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue,
+			(GLubyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor4ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue,
+			(GLuint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor4us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue,
+			(GLushort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor3ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor3uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor3usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor4bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor4ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor4uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor4usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glTexCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glTexCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1i ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1i (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glTexCoord1i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1s ( GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1s (
+		JNIEnv *env, jobject obj,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glTexCoord1s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glTexCoord2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord1iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord1sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glRasterPos2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectd (
+		JNIEnv *env, jobject obj,
+		jdouble x1,
+		jdouble y1,
+		jdouble x2,
+		jdouble y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRectd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x1,
+			(GLdouble) y1,
+			(GLdouble) x2,
+			(GLdouble) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectf (
+		JNIEnv *env, jobject obj,
+		jfloat x1,
+		jfloat y1,
+		jfloat x2,
+		jfloat y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRectf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x1,
+			(GLfloat) y1,
+			(GLfloat) x2,
+			(GLfloat) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRecti (
+		JNIEnv *env, jobject obj,
+		jint x1,
+		jint y1,
+		jint x2,
+		jint y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRecti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x1,
+			(GLint) y1,
+			(GLint) x2,
+			(GLint) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRects (
+		JNIEnv *env, jobject obj,
+		jshort x1,
+		jshort y1,
+		jshort x2,
+		jshort y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRects", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x1,
+			(GLshort) y1,
+			(GLshort) x2,
+			(GLshort) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v1,
+		jdoubleArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *, const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *, const GLdouble *))
+				getGLProcAddressHelper("glRectdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0,
+			(const GLdouble *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v1,
+		jfloatArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *, const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *, const GLfloat *))
+				getGLProcAddressHelper("glRectfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0,
+			(const GLfloat *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectiv (
+		JNIEnv *env, jobject obj,
+		jintArray v1,
+		jintArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *, const GLint *) = NULL;
+		jint *ptr0 = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *, const GLint *))
+				getGLProcAddressHelper("glRectiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0,
+			(const GLint *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectsv (
+		JNIEnv *env, jobject obj,
+		jshortArray v1,
+		jshortArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *, const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *, const GLshort *))
+				getGLProcAddressHelper("glRectsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0,
+			(const GLshort *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3B (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3S (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3I (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3F (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3D (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3J (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElement ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElement (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElement", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArrays (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbyteArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3S (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jshortArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3I (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jintArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3F (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jfloatArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3D (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jdoubleArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbooleanArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3J (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jlongArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glShadeModel ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glShadeModel (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glShadeModel", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightf (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glLightf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLighti (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glLighti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glLightModelf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeli (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glLightModeli", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightModelfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeliv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glLightModeliv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialf (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glMaterialf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMateriali (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glMateriali", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMaterial (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glColorMaterial", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelZoom (
+		JNIEnv *env, jobject obj,
+		jfloat xfactor,
+		jfloat yfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPixelZoom", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) xfactor,
+			(GLfloat) yfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStoref (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelStoref", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStorei (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelStorei", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelTransferf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelTransferi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLfloat *))
+				getGLProcAddressHelper("glPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLfloat *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLuint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLuint *))
+				getGLProcAddressHelper("glPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLuint *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLushort *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLushort *))
+				getGLProcAddressHelper("glPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLushort *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLfloat *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint *))
+				getGLProcAddressHelper("glGetPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLuint *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLushort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLushort *))
+				getGLProcAddressHelper("glGetPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLushort *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBitmap (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jfloat xorig,
+		jfloat yorig,
+		jfloat xmove,
+		jfloat ymove,
+		jbyteArray bitmap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))
+				getGLProcAddressHelper("glBitmap", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(bitmap!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, bitmap, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLfloat) xorig,
+			(GLfloat) yorig,
+			(GLfloat) xmove,
+			(GLfloat) ymove,
+			(const GLubyte *) ptr6
+		);
+
+		if(bitmap!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  bitmap, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyPixels (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint type)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum))
+				getGLProcAddressHelper("glCopyPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jint ref,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLuint))
+				getGLProcAddressHelper("glStencilFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLint) ref,
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glStencilMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilOp (
+		JNIEnv *env, jobject obj,
+		jint fail,
+		jint zfail,
+		jint zpass)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum))
+				getGLProcAddressHelper("glStencilOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) fail,
+			(GLenum) zfail,
+			(GLenum) zpass
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearStencil ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearStencil (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glClearStencil", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGend (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdouble param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble))
+				getGLProcAddressHelper("glTexGend", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenf (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexGenf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeni (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexGeni", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLdouble *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLdouble *))
+				getGLProcAddressHelper("glTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexEnvf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvi (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexEnvi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexLevelParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLfloat *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexLevelParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLint *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTexture (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResident (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResident", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTexture (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint stride,
+		jint order,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLdouble *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint stride,
+		jint order,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLfloat *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint ustride,
+		jint uorder,
+		jdouble v1,
+		jdouble v2,
+		jint vstride,
+		jint vorder,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLdouble) v1,
+			(GLdouble) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLdouble *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint ustride,
+		jint uorder,
+		jfloat v1,
+		jfloat v2,
+		jint vstride,
+		jint vorder,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLfloat) v1,
+			(GLfloat) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLfloat *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapdv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetMapdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLdouble *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLfloat *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapiv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMapiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLint *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glEvalCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glEvalCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble u,
+		jdouble v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glEvalCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u,
+			(GLdouble) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat u,
+		jfloat v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glEvalCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u,
+			(GLfloat) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2,
+		jint vn,
+		jdouble v1,
+		jdouble v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) vn,
+			(GLdouble) v1,
+			(GLdouble) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2,
+		jint vn,
+		jfloat v1,
+		jfloat v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) vn,
+			(GLfloat) v1,
+			(GLfloat) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint1 ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint1 (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glEvalPoint1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint2 (
+		JNIEnv *env, jobject obj,
+		jint i,
+		jint j)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glEvalPoint2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i,
+			(GLint) j
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh1 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh2 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2,
+		jint j1,
+		jint j2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2,
+			(GLint) j1,
+			(GLint) j2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glFogf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glFogi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glFogfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogiv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glFogiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFeedbackBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jfloatArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, GLfloat *))
+				getGLProcAddressHelper("glFeedbackBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, buffer, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLenum) type,
+			(GLfloat *) ptr2
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPassThrough ( GLfloat token ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPassThrough (
+		JNIEnv *env, jobject obj,
+		jfloat token)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPassThrough", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) token
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSelectBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jintArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glSelectBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, buffer, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLuint *) ptr1
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInitNames ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInitNames (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glInitNames", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glLoadName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glPushName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopName ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopName (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorSubTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquation ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquation (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquation", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHistogram (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint width,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, GLboolean))
+				getGLProcAddressHelper("glHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) width,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetHistogram ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetHistogram (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetHistogramParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetHistogramParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMinmax (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLboolean))
+				getGLProcAddressHelper("glMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetMinmax ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetMinmax (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMinmaxParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMinmaxParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glConvolutionParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glConvolutionParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3B_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column,
+		jbyteArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3S_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column,
+		jshortArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3I_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column,
+		jintArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3F_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column,
+		jfloatArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3D_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column,
+		jdoubleArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3Z_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column,
+		jbooleanArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3J_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column,
+		jlongArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColorEXT (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColorEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffsetEXT (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat bias)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffsetEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) bias
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3DEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResidentEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResidentEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointerEXT (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, const GLboolean *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLboolean *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElementEXT ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElementEXT (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElementEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquationEXT (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquationEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPointParameterfEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glPointParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterivEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameterivEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLockArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLsizei))
+				getGLProcAddressHelper("glLockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glUnlockArraysEXT ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glUnlockArraysEXT (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glUnlockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClientActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glClientActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord1dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord1dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord1fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord1fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glMultiTexCoord1iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord1ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord1sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord1svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord2dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord2dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord2fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord2fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord2iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord2ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord2sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord2svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord3dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord3dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord3fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord3fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord3iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord3ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord3sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord3svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord4dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord4dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord4fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord4fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord4iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord4ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord4sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord4svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGL_JauJNInf_dynfuncs.c b/CNativeCode/OpenGL_JauJNInf_dynfuncs.c
new file mode 100644
index 0000000..9bc6a0c
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNInf_dynfuncs.c
@@ -0,0 +1,23658 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNInf.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+    gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNInf_glGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char * tmpString=0;
+
+    tmpString = glGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_gl_n_a_string;
+ 
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNInf_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNInf_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_version_);   
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLFuncJauJNInf ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearIndex ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClearIndex (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glClearIndex", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClearColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glClearColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClear ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClear (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glClear", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIndexMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorMask (
+		JNIEnv *env, jobject obj,
+		jboolean red,
+		jboolean green,
+		jboolean blue,
+		jboolean alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean, GLboolean, GLboolean, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean, GLboolean, GLboolean, GLboolean))
+				getGLProcAddressHelper("glColorMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) red,
+			(GLboolean) green,
+			(GLboolean) blue,
+			(GLboolean) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glAlphaFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jfloat ref)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLclampf))
+				getGLProcAddressHelper("glAlphaFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLclampf) ref
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBlendFunc (
+		JNIEnv *env, jobject obj,
+		jint sfactor,
+		jint dfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glBlendFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) sfactor,
+			(GLenum) dfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLogicOp ( GLenum opcode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLogicOp (
+		JNIEnv *env, jobject obj,
+		jint opcode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glLogicOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) opcode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCullFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCullFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glCullFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrontFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFrontFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glFrontFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointSize ( GLfloat size ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPointSize (
+		JNIEnv *env, jobject obj,
+		jfloat size)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPointSize", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) size
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineWidth ( GLfloat width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLineWidth (
+		JNIEnv *env, jobject obj,
+		jfloat width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glLineWidth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLineStipple (
+		JNIEnv *env, jobject obj,
+		jint factor,
+		jshort pattern)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLushort))
+				getGLProcAddressHelper("glLineStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) factor,
+			(GLushort) pattern
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPolygonMode (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glPolygonMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPolygonOffset (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat units)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffset", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) units
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte *))
+				getGLProcAddressHelper("glGetPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, &isCopiedArray0);
+		}
+		__func_ptr__ (
+			(GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlag (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glEdgeFlag", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagv (
+		JNIEnv *env, jobject obj,
+		jbooleanArray flag)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLboolean *) = NULL;
+		jboolean *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(flag!=NULL)
+		{
+			ptr0 = (*env)->GetBooleanArrayElements(env, flag, 0);
+		}
+		__func_ptr__ (
+			(const GLboolean *) ptr0
+		);
+
+		if(flag!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  flag, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glScissor (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glScissor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, 0);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(const GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDrawBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glReadBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEnable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDisable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIsEnabled (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glIsEnabled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLenum) cap
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEnableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDisableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetBooleanv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean *))
+				getGLProcAddressHelper("glGetBooleanv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLboolean *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetDoublev (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetDoublev", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLdouble *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetFloatv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetFloatv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetIntegerv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint *))
+				getGLProcAddressHelper("glGetIntegerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPushAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPopAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPushClientAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopClientAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPopClientAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRenderMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glRenderMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLenum) mode
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLenum glGetError ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetError (
+		JNIEnv *env, jobject obj)
+	{
+		static jint (CALLBACK *__func_ptr__)() = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)())
+				getGLProcAddressHelper("glGetError", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFinish ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFinish (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFinish", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFlush ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFlush (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFlush", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glHint (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glHint", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearDepth ( GLclampd depth ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClearDepth (
+		JNIEnv *env, jobject obj,
+		jdouble depth)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd))
+				getGLProcAddressHelper("glClearDepth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) depth
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthFunc ( GLenum func ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDepthFunc (
+		JNIEnv *env, jobject obj,
+		jint func)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDepthFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthMask ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDepthMask (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glDepthMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDepthRange (
+		JNIEnv *env, jobject obj,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd, GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd, GLclampd))
+				getGLProcAddressHelper("glDepthRange", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) near_val,
+			(GLclampd) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClearAccum (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glClearAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glAccum (
+		JNIEnv *env, jobject obj,
+		jint op,
+		jfloat value)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) op,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMatrixMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMatrixMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glMatrixMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glOrtho (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glOrtho", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFrustum (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glFrustum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glViewport (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glViewport", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPushMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPushMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPopMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadIdentity ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLoadIdentity (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glLoadIdentity", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLoadMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glLoadMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLoadMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glLoadMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glMultMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glMultMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRotated (
+		JNIEnv *env, jobject obj,
+		jdouble angle,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRotated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) angle,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRotatef (
+		JNIEnv *env, jobject obj,
+		jfloat angle,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRotatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) angle,
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glScaled (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glScaled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glScalef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glScalef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTranslated (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTranslated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTranslatef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTranslatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIsList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) list
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDeleteLists (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint range)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLsizei))
+				getGLProcAddressHelper("glDeleteLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLsizei) range
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGenLists (
+		JNIEnv *env, jobject obj,
+		jint range)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLsizei) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLsizei))
+				getGLProcAddressHelper("glGenLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLsizei) range
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNewList (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLenum))
+				getGLProcAddressHelper("glNewList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEndList ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEndList (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEndList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glCallList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3B (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbyteArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3S (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jshortArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3I (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jintArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3F (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jfloatArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3D (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jdoubleArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbooleanArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCallLists__II_3J (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jlongArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, lists, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glListBase ( GLuint base ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glListBase (
+		JNIEnv *env, jobject obj,
+		jint base)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glListBase", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) base
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBegin ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBegin (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBegin", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnd ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEnd (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEnd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glVertex2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glVertex2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertex4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3b (
+		JNIEnv *env, jobject obj,
+		jbyte nx,
+		jbyte ny,
+		jbyte nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glNormal3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) nx,
+			(GLbyte) ny,
+			(GLbyte) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3d (
+		JNIEnv *env, jobject obj,
+		jdouble nx,
+		jdouble ny,
+		jdouble nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glNormal3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) nx,
+			(GLdouble) ny,
+			(GLdouble) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3f (
+		JNIEnv *env, jobject obj,
+		jfloat nx,
+		jfloat ny,
+		jfloat nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glNormal3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) nx,
+			(GLfloat) ny,
+			(GLfloat) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3i (
+		JNIEnv *env, jobject obj,
+		jint nx,
+		jint ny,
+		jint nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glNormal3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) nx,
+			(GLint) ny,
+			(GLint) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3s (
+		JNIEnv *env, jobject obj,
+		jshort nx,
+		jshort ny,
+		jshort nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glNormal3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) nx,
+			(GLshort) ny,
+			(GLshort) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glNormal3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glNormal3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glNormal3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glNormal3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormal3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glNormal3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexd ( GLdouble c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexd (
+		JNIEnv *env, jobject obj,
+		jdouble c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glIndexd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexf ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexf (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glIndexf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexi ( GLint c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexi (
+		JNIEnv *env, jobject obj,
+		jint c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glIndexi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexs ( GLshort c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexs (
+		JNIEnv *env, jobject obj,
+		jshort c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glIndexs", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexub ( GLubyte c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexub (
+		JNIEnv *env, jobject obj,
+		jbyte c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte))
+				getGLProcAddressHelper("glIndexub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glIndexdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glIndexfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexiv ( const GLint * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexiv (
+		JNIEnv *env, jobject obj,
+		jintArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glIndexiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexsv ( const GLshort * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexsv (
+		JNIEnv *env, jobject obj,
+		jshortArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glIndexsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glIndexubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, c, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor3ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor3ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor3us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor4b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue,
+			(GLbyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue,
+		jdouble alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue,
+			(GLdouble) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue,
+			(GLint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue,
+			(GLshort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor4ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue,
+			(GLubyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor4ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue,
+			(GLuint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor4us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue,
+			(GLushort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor3ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor3uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor3usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor3usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor4bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jbyte *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor4ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor4uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColor4usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor4usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glTexCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glTexCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1i ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1i (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glTexCoord1i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1s ( GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1s (
+		JNIEnv *env, jobject obj,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glTexCoord1s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glTexCoord2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord1iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord1sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord1sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoord4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glRasterPos2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jint *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRasterPos4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectd (
+		JNIEnv *env, jobject obj,
+		jdouble x1,
+		jdouble y1,
+		jdouble x2,
+		jdouble y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRectd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x1,
+			(GLdouble) y1,
+			(GLdouble) x2,
+			(GLdouble) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectf (
+		JNIEnv *env, jobject obj,
+		jfloat x1,
+		jfloat y1,
+		jfloat x2,
+		jfloat y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRectf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x1,
+			(GLfloat) y1,
+			(GLfloat) x2,
+			(GLfloat) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRecti (
+		JNIEnv *env, jobject obj,
+		jint x1,
+		jint y1,
+		jint x2,
+		jint y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRecti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x1,
+			(GLint) y1,
+			(GLint) x2,
+			(GLint) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRects (
+		JNIEnv *env, jobject obj,
+		jshort x1,
+		jshort y1,
+		jshort x2,
+		jshort y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRects", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x1,
+			(GLshort) y1,
+			(GLshort) x2,
+			(GLshort) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v1,
+		jdoubleArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *, const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *, const GLdouble *))
+				getGLProcAddressHelper("glRectdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0,
+			(const GLdouble *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v1,
+		jfloatArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *, const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *, const GLfloat *))
+				getGLProcAddressHelper("glRectfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0,
+			(const GLfloat *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectiv (
+		JNIEnv *env, jobject obj,
+		jintArray v1,
+		jintArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *, const GLint *) = NULL;
+		jint *ptr0 = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *, const GLint *))
+				getGLProcAddressHelper("glRectiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0,
+			(const GLint *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glRectsv (
+		JNIEnv *env, jobject obj,
+		jshortArray v1,
+		jshortArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *, const GLshort *) = NULL;
+		jshort *ptr0 = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *, const GLshort *))
+				getGLProcAddressHelper("glRectsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v1, 0);
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v2, 0);
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0,
+			(const GLshort *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3B (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3S (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3I (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3F (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3D (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointer__I_3J (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointerv__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElement ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glArrayElement (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElement", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawArrays (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawElements__III_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbyteArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3S (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jshortArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3I (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jintArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3F (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jfloatArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3D (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jdoubleArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbooleanArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInterleavedArrays__II_3J (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jlongArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, pointer, 0);
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glShadeModel ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glShadeModel (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glShadeModel", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightf (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glLightf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLighti (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glLighti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightModelf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glLightModelf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightModeli (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glLightModeli", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightModelfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightModelfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLightModeliv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glLightModeliv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMaterialf (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glMaterialf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMateriali (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glMateriali", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorMaterial (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glColorMaterial", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelZoom (
+		JNIEnv *env, jobject obj,
+		jfloat xfactor,
+		jfloat yfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPixelZoom", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) xfactor,
+			(GLfloat) yfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelStoref (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelStoref", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelStorei (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelStorei", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelTransferf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelTransferf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelTransferi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelTransferi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLfloat *))
+				getGLProcAddressHelper("glPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLfloat *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLuint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLuint *))
+				getGLProcAddressHelper("glPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLuint *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLushort *) = NULL;
+		jshort *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLushort *))
+				getGLProcAddressHelper("glPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, values, 0);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLushort *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLfloat *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint *))
+				getGLProcAddressHelper("glGetPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLuint *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLushort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLushort *))
+				getGLProcAddressHelper("glGetPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, values, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLushort *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBitmap (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jfloat xorig,
+		jfloat yorig,
+		jfloat xmove,
+		jfloat ymove,
+		jbyteArray bitmap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))
+				getGLProcAddressHelper("glBitmap", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(bitmap!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, bitmap, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLfloat) xorig,
+			(GLfloat) yorig,
+			(GLfloat) xmove,
+			(GLfloat) ymove,
+			(const GLubyte *) ptr6
+		);
+
+		if(bitmap!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  bitmap, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glReadPixels__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray6);
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawPixels__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyPixels (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint type)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum))
+				getGLProcAddressHelper("glCopyPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glStencilFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jint ref,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLuint))
+				getGLProcAddressHelper("glStencilFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLint) ref,
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glStencilMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glStencilMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glStencilOp (
+		JNIEnv *env, jobject obj,
+		jint fail,
+		jint zfail,
+		jint zpass)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum))
+				getGLProcAddressHelper("glStencilOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) fail,
+			(GLenum) zfail,
+			(GLenum) zpass
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearStencil ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClearStencil (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glClearStencil", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGend (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdouble param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble))
+				getGLProcAddressHelper("glTexGend", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGenf (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexGenf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGeni (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexGeni", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLdouble *) = NULL;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLdouble *))
+				getGLProcAddressHelper("glTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexEnvf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexEnvf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexEnvi (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexEnvi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexLevelParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexLevelParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLfloat *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexLevelParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexLevelParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, params, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLint *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage1D__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetTexImage__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGenTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDeleteTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBindTexture (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPrioritizeTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glAreTexturesResident (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResident", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIsTexture (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage1D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr8 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexSubImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexSubImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMap1d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint stride,
+		jint order,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLdouble *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMap1f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint stride,
+		jint order,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLfloat *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMap2d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint ustride,
+		jint uorder,
+		jdouble v1,
+		jdouble v2,
+		jint vstride,
+		jint vorder,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLdouble) v1,
+			(GLdouble) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLdouble *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMap2f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint ustride,
+		jint uorder,
+		jfloat v1,
+		jfloat v2,
+		jint vstride,
+		jint vorder,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, points, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLfloat) v1,
+			(GLfloat) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLfloat *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMapdv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetMapdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLdouble *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMapfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLfloat *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMapiv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMapiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, v, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLint *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glEvalCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glEvalCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble u,
+		jdouble v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glEvalCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u,
+			(GLdouble) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat u,
+		jfloat v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glEvalCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u,
+			(GLfloat) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jdouble *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jfloat *ptr0 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, 0);
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMapGrid1d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMapGrid1f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMapGrid2d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2,
+		jint vn,
+		jdouble v1,
+		jdouble v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) vn,
+			(GLdouble) v1,
+			(GLdouble) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMapGrid2f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2,
+		jint vn,
+		jfloat v1,
+		jfloat v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) vn,
+			(GLfloat) v1,
+			(GLfloat) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint1 ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalPoint1 (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glEvalPoint1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalPoint2 (
+		JNIEnv *env, jobject obj,
+		jint i,
+		jint j)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glEvalPoint2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i,
+			(GLint) j
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalMesh1 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEvalMesh2 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2,
+		jint j1,
+		jint j2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2,
+			(GLint) j1,
+			(GLint) j2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFogf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glFogf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFogi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glFogi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFogfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glFogfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFogiv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glFogiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glFeedbackBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jfloatArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, GLfloat *))
+				getGLProcAddressHelper("glFeedbackBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, buffer, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLenum) type,
+			(GLfloat *) ptr2
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPassThrough ( GLfloat token ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPassThrough (
+		JNIEnv *env, jobject obj,
+		jfloat token)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPassThrough", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) token
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSelectBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jintArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glSelectBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, buffer, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLuint *) ptr1
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInitNames ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glInitNames (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glInitNames", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLoadName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glLoadName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPushName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glPushName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopName ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPopName (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawRangeElements__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, indices, 0);
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3D__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3D__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexSubImage3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyColorSubTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyColorTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTable__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquation ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBlendEquation (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquation", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBlendColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glHistogram (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint width,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, GLboolean))
+				getGLProcAddressHelper("glHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) width,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetHistogram ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glResetHistogram (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogram__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogramParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetHistogramParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetHistogramParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetHistogramParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMinmax (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLboolean))
+				getGLProcAddressHelper("glMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetMinmax ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glResetMinmax (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmax__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmaxParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMinmaxParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetMinmaxParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMinmaxParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter1D__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionFilter2D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, image, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glConvolutionParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glConvolutionParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyConvolutionFilter1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyConvolutionFilter2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionFilter__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, image, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jbyte *ptr6 = NULL;
+		jbyte *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jshort *ptr6 = NULL;
+		jshort *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jint *ptr6 = NULL;
+		jint *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jfloat *ptr6 = NULL;
+		jfloat *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jdouble *ptr6 = NULL;
+		jdouble *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean *ptr6 = NULL;
+		jboolean *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glSeparableFilter2D__IIIIII_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jlong *ptr6 = NULL;
+		jlong *ptr7 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, row, 0);
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, column, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3B_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column,
+		jbyteArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3S_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column,
+		jshortArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3I_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column,
+		jintArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3F_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column,
+		jfloatArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3D_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column,
+		jdoubleArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3Z_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column,
+		jbooleanArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetSeparableFilter__III_3J_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column,
+		jlongArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, row, &isCopiedArray3);
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, column, &isCopiedArray4);
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, span, &isCopiedArray5);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBlendColorEXT (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColorEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPolygonOffsetEXT (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat bias)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffsetEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) bias
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexImage3DEXT__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr9 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexSubImage3DEXT__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr10 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glCopyTexSubImage3DEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGenTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDeleteTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBindTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPrioritizeTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jint *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glAreTexturesResidentEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jint *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResidentEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, 0);
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIsTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glVertexPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glNormalPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glIndexPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jbyte *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jshort *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jint *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jfloat *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jdouble *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glTexCoordPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jlong *ptr4 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glEdgeFlagPointerEXT (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, const GLboolean *) = NULL;
+		jboolean *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, 0);
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLboolean *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetPointervEXT__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElementEXT ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glArrayElementEXT (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElementEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glDrawArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glBlendEquationEXT (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquationEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPointParameterfEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPointParameterfEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glPointParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glPointParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, 0);
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jbyte *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jshort *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jint *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jfloat *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jdouble *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glColorSubTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jlong *ptr5 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glGetColorTableParameterivEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameterivEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glLockArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLsizei))
+				getGLProcAddressHelper("glLockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glUnlockArraysEXT ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glUnlockArraysEXT (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glUnlockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glClientActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glClientActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord1dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord1dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord1fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord1fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glMultiTexCoord1iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord1ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord1sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord1svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord1svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord2dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord2dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord2fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord2fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord2iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord2ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord2sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord2svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord2svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord3dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord3dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord3fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord3fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord3iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord3ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord3sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord3svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord3svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord4dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jdouble *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord4dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord4fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jfloat *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord4fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord4iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jint *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord4ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord4sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNInf_glMultiTexCoord4svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jshort *ptr1 = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord4svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, 0);
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGL_JauJNItst_dynfuncs.c b/CNativeCode/OpenGL_JauJNItst_dynfuncs.c
new file mode 100644
index 0000000..1782e0c
--- /dev/null
+++ b/CNativeCode/OpenGL_JauJNItst_dynfuncs.c
@@ -0,0 +1,26455 @@
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+/** THIS IS A MANUAL CODED PART
+    gl-manualCodedImplJNI.java
+*/
+
+static const char _gl_n_a_string[] = "GL-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_glGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char * tmpString=0;
+
+    tmpString = glGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_gl_n_a_string;
+ 
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+static const char * _gl_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _gl_lib_version_="2.4.1.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLFuncJauJNI_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _gl_lib_version_);   
+}
+
+/**
+ * C2J Parser Version 1.4 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: gl-proto-auto.orig . . .
+ * Destination-Class: gl4java_GLFuncJauJNI ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearIndex ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearIndex (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glClearIndex", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glClearColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClear ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClear (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glClear", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIndexMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMask ( GLboolean red , GLboolean green , GLboolean blue , GLboolean alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMask (
+		JNIEnv *env, jobject obj,
+		jboolean red,
+		jboolean green,
+		jboolean blue,
+		jboolean alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean, GLboolean, GLboolean, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean, GLboolean, GLboolean, GLboolean))
+				getGLProcAddressHelper("glColorMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) red,
+			(GLboolean) green,
+			(GLboolean) blue,
+			(GLboolean) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAlphaFunc ( GLenum func , GLclampf ref ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAlphaFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jfloat ref)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLclampf))
+				getGLProcAddressHelper("glAlphaFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLclampf) ref
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendFunc ( GLenum sfactor , GLenum dfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendFunc (
+		JNIEnv *env, jobject obj,
+		jint sfactor,
+		jint dfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glBlendFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) sfactor,
+			(GLenum) dfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLogicOp ( GLenum opcode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLogicOp (
+		JNIEnv *env, jobject obj,
+		jint opcode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glLogicOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) opcode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCullFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCullFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glCullFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrontFace ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrontFace (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glFrontFace", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointSize ( GLfloat size ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointSize (
+		JNIEnv *env, jobject obj,
+		jfloat size)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPointSize", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) size
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineWidth ( GLfloat width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineWidth (
+		JNIEnv *env, jobject obj,
+		jfloat width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glLineWidth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLineStipple ( GLint factor , GLushort pattern ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLineStipple (
+		JNIEnv *env, jobject obj,
+		jint factor,
+		jshort pattern)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLushort))
+				getGLProcAddressHelper("glLineStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) factor,
+			(GLushort) pattern
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonMode ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonMode (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glPolygonMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffset ( GLfloat factor , GLfloat units ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffset (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat units)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffset", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) units
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonStipple ( const GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glPolygonStipple arg: mask");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPolygonStipple ( GLubyte * mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPolygonStipple (
+		JNIEnv *env, jobject obj,
+		jbyteArray mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte *))
+				getGLProcAddressHelper("glGetPolygonStipple", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(mask!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, mask, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glGetPolygonStipple arg: mask");
+			}
+		}
+		__func_ptr__ (
+			(GLubyte *) ptr0
+		);
+
+		if(mask!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  mask, ptr0, (isCopiedArray0 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlag ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlag (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glEdgeFlag", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagv ( const GLboolean * flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagv (
+		JNIEnv *env, jobject obj,
+		jbooleanArray flag)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLboolean *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jboolean *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(flag!=NULL)
+		{
+			ptr0 = (*env)->GetBooleanArrayElements(env, flag, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEdgeFlagv arg: flag");
+			}
+		}
+		__func_ptr__ (
+			(const GLboolean *) ptr0
+		);
+
+		if(flag!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  flag, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScissor ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScissor (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glScissor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClipPlane ( GLenum plane , const GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glClipPlane arg: equation");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(const GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetClipPlane ( GLenum plane , GLdouble * equation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetClipPlane (
+		JNIEnv *env, jobject obj,
+		jint plane,
+		jdoubleArray equation)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetClipPlane", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(equation!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, equation, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetClipPlane arg: equation");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) plane,
+			(GLdouble *) ptr1
+		);
+
+		if(equation!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  equation, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDrawBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadBuffer ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadBuffer (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glReadBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisable ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisable (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsEnabled ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsEnabled (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glIsEnabled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLenum) cap
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glEnableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDisableClientState ( GLenum cap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDisableClientState (
+		JNIEnv *env, jobject obj,
+		jint cap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDisableClientState", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) cap
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetBooleanv ( GLenum pname , GLboolean * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetBooleanv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean *))
+				getGLProcAddressHelper("glGetBooleanv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetBooleanv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLboolean *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetDoublev ( GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetDoublev (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetDoublev", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetDoublev arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLdouble *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetFloatv ( GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetFloatv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetFloatv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetFloatv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetIntegerv ( GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetIntegerv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint *))
+				getGLProcAddressHelper("glGetIntegerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetIntegerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushClientAttrib ( GLbitfield mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushClientAttrib (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbitfield) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbitfield))
+				getGLProcAddressHelper("glPushClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbitfield) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopClientAttrib ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopClientAttrib (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopClientAttrib", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint glRenderMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glRenderMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLenum) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glRenderMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLenum) mode
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLenum glGetError ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetError (
+		JNIEnv *env, jobject obj)
+	{
+		static jint (CALLBACK *__func_ptr__)() = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)())
+				getGLProcAddressHelper("glGetError", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFinish ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFinish (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFinish", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFlush ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFlush (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glFlush", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHint ( GLenum target , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHint (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glHint", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearDepth ( GLclampd depth ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearDepth (
+		JNIEnv *env, jobject obj,
+		jdouble depth)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd))
+				getGLProcAddressHelper("glClearDepth", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) depth
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthFunc ( GLenum func ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthFunc (
+		JNIEnv *env, jobject obj,
+		jint func)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glDepthFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthMask ( GLboolean flag ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthMask (
+		JNIEnv *env, jobject obj,
+		jboolean flag)
+	{
+		static void (CALLBACK *__func_ptr__)(GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLboolean))
+				getGLProcAddressHelper("glDepthMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLboolean) flag
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDepthRange ( GLclampd near_val , GLclampd far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDepthRange (
+		JNIEnv *env, jobject obj,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampd, GLclampd) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampd, GLclampd))
+				getGLProcAddressHelper("glDepthRange", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampd) near_val,
+			(GLclampd) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearAccum ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearAccum (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glClearAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glAccum ( GLenum op , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glAccum (
+		JNIEnv *env, jobject obj,
+		jint op,
+		jfloat value)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glAccum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) op,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMatrixMode ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMatrixMode (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glMatrixMode", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glOrtho ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glOrtho (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glOrtho", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFrustum ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top , GLdouble near_val , GLdouble far_val ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFrustum (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top,
+		jdouble near_val,
+		jdouble far_val)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glFrustum", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top,
+			(GLdouble) near_val,
+			(GLdouble) far_val
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glViewport ( GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glViewport (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glViewport", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPushMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopMatrix ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopMatrix (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopMatrix", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadIdentity ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadIdentity (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glLoadIdentity", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glLoadMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glLoadMatrixd arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glLoadMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glLoadMatrixf arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixd ( const GLdouble * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixd (
+		JNIEnv *env, jobject obj,
+		jdoubleArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glMultMatrixd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glMultMatrixd arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultMatrixf ( const GLfloat * m ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultMatrixf (
+		JNIEnv *env, jobject obj,
+		jfloatArray m)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glMultMatrixf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(m!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, m, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glMultMatrixf arg: m");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(m!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  m, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotated ( GLdouble angle , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotated (
+		JNIEnv *env, jobject obj,
+		jdouble angle,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRotated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) angle,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRotatef ( GLfloat angle , GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRotatef (
+		JNIEnv *env, jobject obj,
+		jfloat angle,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRotatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) angle,
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScaled ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScaled (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glScaled", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glScalef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glScalef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glScalef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslated ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslated (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTranslated", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTranslatef ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTranslatef (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTranslatef", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) list
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteLists ( GLuint list , GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteLists (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint range)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLsizei))
+				getGLProcAddressHelper("glDeleteLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLsizei) range
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLuint glGenLists ( GLsizei range ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenLists (
+		JNIEnv *env, jobject obj,
+		jint range)
+	{
+		static jint (CALLBACK *__func_ptr__)(GLsizei) = NULL;
+		jint ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jint (CALLBACK *)(GLsizei))
+				getGLProcAddressHelper("glGenLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jint) __func_ptr__ (
+			(GLsizei) range
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNewList ( GLuint list , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNewList (
+		JNIEnv *env, jobject obj,
+		jint list,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLenum))
+				getGLProcAddressHelper("glNewList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEndList ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEndList (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEndList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallList ( GLuint list ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallList (
+		JNIEnv *env, jobject obj,
+		jint list)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glCallList", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) list
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCallLists ( GLsizei n , GLenum type , const GLvoid * lists ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3B (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbyteArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3S (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jshortArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3I (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jintArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3F (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jfloatArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3D (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jdoubleArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jbooleanArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCallLists__II_3J (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jint type,
+		jlongArray lists)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glCallLists", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(lists!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, lists, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glCallLists arg: lists");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLenum) type,
+			(const GLvoid *) ptr2
+		);
+
+		if(lists!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  lists, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glListBase ( GLuint base ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glListBase (
+		JNIEnv *env, jobject obj,
+		jint base)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glListBase", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) base
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBegin ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBegin (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBegin", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEnd ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEnd (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glEnd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glVertex2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glVertex2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glVertex4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glVertex4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glVertex4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glVertex4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glVertex4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glVertex4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glVertex4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertex4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertex4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glVertex4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glVertex4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3b ( GLbyte nx , GLbyte ny , GLbyte nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3b (
+		JNIEnv *env, jobject obj,
+		jbyte nx,
+		jbyte ny,
+		jbyte nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glNormal3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) nx,
+			(GLbyte) ny,
+			(GLbyte) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3d ( GLdouble nx , GLdouble ny , GLdouble nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3d (
+		JNIEnv *env, jobject obj,
+		jdouble nx,
+		jdouble ny,
+		jdouble nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glNormal3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) nx,
+			(GLdouble) ny,
+			(GLdouble) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3f ( GLfloat nx , GLfloat ny , GLfloat nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3f (
+		JNIEnv *env, jobject obj,
+		jfloat nx,
+		jfloat ny,
+		jfloat nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glNormal3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) nx,
+			(GLfloat) ny,
+			(GLfloat) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3i ( GLint nx , GLint ny , GLint nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3i (
+		JNIEnv *env, jobject obj,
+		jint nx,
+		jint ny,
+		jint nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glNormal3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) nx,
+			(GLint) ny,
+			(GLint) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3s ( GLshort nx , GLshort ny , GLshort nz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3s (
+		JNIEnv *env, jobject obj,
+		jshort nx,
+		jshort ny,
+		jshort nz)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glNormal3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) nx,
+			(GLshort) ny,
+			(GLshort) nz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glNormal3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glNormal3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glNormal3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glNormal3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormal3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormal3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glNormal3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glNormal3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexd ( GLdouble c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexd (
+		JNIEnv *env, jobject obj,
+		jdouble c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glIndexd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexf ( GLfloat c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexf (
+		JNIEnv *env, jobject obj,
+		jfloat c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glIndexf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexi ( GLint c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexi (
+		JNIEnv *env, jobject obj,
+		jint c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glIndexi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexs ( GLshort c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexs (
+		JNIEnv *env, jobject obj,
+		jshort c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glIndexs", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexub ( GLubyte c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexub (
+		JNIEnv *env, jobject obj,
+		jbyte c)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte))
+				getGLProcAddressHelper("glIndexub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) c
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexdv ( const GLdouble * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glIndexdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexdv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexfv ( const GLfloat * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glIndexfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexfv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexiv ( const GLint * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexiv (
+		JNIEnv *env, jobject obj,
+		jintArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glIndexiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexiv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexsv ( const GLshort * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexsv (
+		JNIEnv *env, jobject obj,
+		jshortArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glIndexsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexsv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexubv ( const GLubyte * c ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray c)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glIndexubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(c!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, c, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glIndexubv arg: c");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(c!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  c, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3b ( GLbyte red , GLbyte green , GLbyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor3b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3d ( GLdouble red , GLdouble green , GLdouble blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3f ( GLfloat red , GLfloat green , GLfloat blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3i ( GLint red , GLint green , GLint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3s ( GLshort red , GLshort green , GLshort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ub ( GLubyte red , GLubyte green , GLubyte blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor3ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ui ( GLuint red , GLuint green , GLuint blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor3ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3us ( GLushort red , GLushort green , GLushort blue ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor3us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4b ( GLbyte red , GLbyte green , GLbyte blue , GLbyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4b (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLbyte, GLbyte, GLbyte, GLbyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLbyte, GLbyte, GLbyte, GLbyte))
+				getGLProcAddressHelper("glColor4b", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLbyte) red,
+			(GLbyte) green,
+			(GLbyte) blue,
+			(GLbyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4d ( GLdouble red , GLdouble green , GLdouble blue , GLdouble alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4d (
+		JNIEnv *env, jobject obj,
+		jdouble red,
+		jdouble green,
+		jdouble blue,
+		jdouble alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glColor4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) red,
+			(GLdouble) green,
+			(GLdouble) blue,
+			(GLdouble) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4f ( GLfloat red , GLfloat green , GLfloat blue , GLfloat alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4f (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glColor4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) red,
+			(GLfloat) green,
+			(GLfloat) blue,
+			(GLfloat) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4i ( GLint red , GLint green , GLint blue , GLint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4i (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glColor4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) red,
+			(GLint) green,
+			(GLint) blue,
+			(GLint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4s ( GLshort red , GLshort green , GLshort blue , GLshort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4s (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glColor4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) red,
+			(GLshort) green,
+			(GLshort) blue,
+			(GLshort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ub ( GLubyte red , GLubyte green , GLubyte blue , GLubyte alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ub (
+		JNIEnv *env, jobject obj,
+		jbyte red,
+		jbyte green,
+		jbyte blue,
+		jbyte alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLubyte, GLubyte, GLubyte, GLubyte) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLubyte, GLubyte, GLubyte, GLubyte))
+				getGLProcAddressHelper("glColor4ub", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLubyte) red,
+			(GLubyte) green,
+			(GLubyte) blue,
+			(GLubyte) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ui ( GLuint red , GLuint green , GLuint blue , GLuint alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ui (
+		JNIEnv *env, jobject obj,
+		jint red,
+		jint green,
+		jint blue,
+		jint alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint, GLuint, GLuint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint, GLuint, GLuint, GLuint))
+				getGLProcAddressHelper("glColor4ui", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) red,
+			(GLuint) green,
+			(GLuint) blue,
+			(GLuint) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4us ( GLushort red , GLushort green , GLushort blue , GLushort alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4us (
+		JNIEnv *env, jobject obj,
+		jshort red,
+		jshort green,
+		jshort blue,
+		jshort alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLushort, GLushort, GLushort, GLushort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLushort, GLushort, GLushort, GLushort))
+				getGLProcAddressHelper("glColor4us", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLushort) red,
+			(GLushort) green,
+			(GLushort) blue,
+			(GLushort) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor3bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor3ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3ubv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor3uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3uiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor3usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor3usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor3usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor3usv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4bv ( const GLbyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4bv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLbyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLbyte *))
+				getGLProcAddressHelper("glColor4bv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4bv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLbyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glColor4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glColor4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glColor4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glColor4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4ubv ( const GLubyte * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4ubv (
+		JNIEnv *env, jobject obj,
+		jbyteArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLubyte *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jbyte *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLubyte *))
+				getGLProcAddressHelper("glColor4ubv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetByteArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4ubv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLubyte *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4uiv ( const GLuint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4uiv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLuint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLuint *))
+				getGLProcAddressHelper("glColor4uiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4uiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLuint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColor4usv ( const GLushort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColor4usv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLushort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLushort *))
+				getGLProcAddressHelper("glColor4usv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glColor4usv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLushort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1d ( GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glTexCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1f ( GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glTexCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1i ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1i (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glTexCoord1i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1s ( GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1s (
+		JNIEnv *env, jobject obj,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort))
+				getGLProcAddressHelper("glTexCoord1s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2d ( GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2f ( GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2i ( GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glTexCoord2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2s ( GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3d ( GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3f ( GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3i ( GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3s ( GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4d ( GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4d (
+		JNIEnv *env, jobject obj,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glTexCoord4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4f ( GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4f (
+		JNIEnv *env, jobject obj,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glTexCoord4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4i ( GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4i (
+		JNIEnv *env, jobject obj,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glTexCoord4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4s ( GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4s (
+		JNIEnv *env, jobject obj,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glTexCoord4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord1iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord1sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord1sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord1sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord1sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glTexCoord4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glTexCoord4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glTexCoord4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoord4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoord4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glTexCoord4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glTexCoord4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2d ( GLdouble x , GLdouble y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2f ( GLfloat x , GLfloat y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2i ( GLint x , GLint y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glRasterPos2i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2s ( GLshort x , GLshort y ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos2s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3d ( GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos3d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3f ( GLfloat x , GLfloat y , GLfloat z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos3f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3i ( GLint x , GLint y , GLint z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos3i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3s ( GLshort x , GLshort y , GLshort z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos3s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4d ( GLdouble x , GLdouble y , GLdouble z , GLdouble w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4d (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble z,
+		jdouble w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRasterPos4d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z,
+			(GLdouble) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4f ( GLfloat x , GLfloat y , GLfloat z , GLfloat w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4f (
+		JNIEnv *env, jobject obj,
+		jfloat x,
+		jfloat y,
+		jfloat z,
+		jfloat w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRasterPos4f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x,
+			(GLfloat) y,
+			(GLfloat) z,
+			(GLfloat) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4i ( GLint x , GLint y , GLint z , GLint w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4i (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint z,
+		jint w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRasterPos4i", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLint) z,
+			(GLint) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4s ( GLshort x , GLshort y , GLshort z , GLshort w ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4s (
+		JNIEnv *env, jobject obj,
+		jshort x,
+		jshort y,
+		jshort z,
+		jshort w)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRasterPos4s", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x,
+			(GLshort) y,
+			(GLshort) z,
+			(GLshort) w
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos2iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos2sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos2sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos2sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos2sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos3dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos3fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos3iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos3sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos3sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos3sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos3sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4dv ( const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glRasterPos4dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4dv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4fv ( const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glRasterPos4fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4fv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4iv ( const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4iv (
+		JNIEnv *env, jobject obj,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *))
+				getGLProcAddressHelper("glRasterPos4iv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4iv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRasterPos4sv ( const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRasterPos4sv (
+		JNIEnv *env, jobject obj,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *))
+				getGLProcAddressHelper("glRasterPos4sv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRasterPos4sv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectd ( GLdouble x1 , GLdouble y1 , GLdouble x2 , GLdouble y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectd (
+		JNIEnv *env, jobject obj,
+		jdouble x1,
+		jdouble y1,
+		jdouble x2,
+		jdouble y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glRectd", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) x1,
+			(GLdouble) y1,
+			(GLdouble) x2,
+			(GLdouble) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectf ( GLfloat x1 , GLfloat y1 , GLfloat x2 , GLfloat y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectf (
+		JNIEnv *env, jobject obj,
+		jfloat x1,
+		jfloat y1,
+		jfloat x2,
+		jfloat y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glRectf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) x1,
+			(GLfloat) y1,
+			(GLfloat) x2,
+			(GLfloat) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRecti ( GLint x1 , GLint y1 , GLint x2 , GLint y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRecti (
+		JNIEnv *env, jobject obj,
+		jint x1,
+		jint y1,
+		jint x2,
+		jint y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glRecti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x1,
+			(GLint) y1,
+			(GLint) x2,
+			(GLint) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRects ( GLshort x1 , GLshort y1 , GLshort x2 , GLshort y2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRects (
+		JNIEnv *env, jobject obj,
+		jshort x1,
+		jshort y1,
+		jshort x2,
+		jshort y2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glRects", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLshort) x1,
+			(GLshort) y1,
+			(GLshort) x2,
+			(GLshort) y2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectdv ( const GLdouble * v1 , const GLdouble * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectdv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray v1,
+		jdoubleArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *, const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *, const GLdouble *))
+				getGLProcAddressHelper("glRectdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectdv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectdv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0,
+			(const GLdouble *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectfv ( const GLfloat * v1 , const GLfloat * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectfv (
+		JNIEnv *env, jobject obj,
+		jfloatArray v1,
+		jfloatArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *, const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *, const GLfloat *))
+				getGLProcAddressHelper("glRectfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectfv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectfv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0,
+			(const GLfloat *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectiv ( const GLint * v1 , const GLint * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectiv (
+		JNIEnv *env, jobject obj,
+		jintArray v1,
+		jintArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLint *, const GLint *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jint *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLint *, const GLint *))
+				getGLProcAddressHelper("glRectiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetIntArrayElements(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectiv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectiv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLint *) ptr0,
+			(const GLint *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glRectsv ( const GLshort * v1 , const GLshort * v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glRectsv (
+		JNIEnv *env, jobject obj,
+		jshortArray v1,
+		jshortArray v2)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLshort *, const GLshort *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jshort *ptr0 = NULL;
+		static int isWarned0 = 0;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLshort *, const GLshort *))
+				getGLProcAddressHelper("glRectsv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v1!=NULL)
+		{
+			ptr0 = (*env)->GetShortArrayElements(env, v1, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glRectsv arg: v1");
+			}
+		}
+		if(v2!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v2, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glRectsv arg: v2");
+			}
+		}
+		__func_ptr__ (
+			(const GLshort *) ptr0,
+			(const GLshort *) ptr1
+		);
+
+		if(v1!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v1, ptr0, JNI_ABORT);
+		}
+		if(v2!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v2, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glVertexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glNormalPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glColorPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointer ( GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointer__II_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glIndexPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointer ( GLint size , GLenum type , GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointer__III_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glTexCoordPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointer ( GLsizei stride , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3B (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3S (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3I (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3F (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3D (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3Z (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointer__I_3J (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glEdgeFlagPointer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glEdgeFlagPointer arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(const GLvoid *) ptr1
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointerv ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointerv__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointerv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointerv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElement ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElement (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElement", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArrays ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArrays (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawElements ( GLenum mode , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawElements__III_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, indices, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glDrawElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr3
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInterleavedArrays ( GLenum format , GLsizei stride , const GLvoid * pointer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3B (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbyteArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3S (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jshortArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3I (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jintArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3F (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jfloatArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3D (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jdoubleArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3Z (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jbooleanArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInterleavedArrays__II_3J (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint stride,
+		jlongArray pointer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glInterleavedArrays", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pointer!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, pointer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glInterleavedArrays arg: pointer");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) format,
+			(GLsizei) stride,
+			(const GLvoid *) ptr2
+		);
+
+		if(pointer!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pointer, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glShadeModel ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glShadeModel (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glShadeModel", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightf ( GLenum light , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightf (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glLightf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLighti ( GLenum light , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLighti (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glLighti", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightfv ( GLenum light , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glLightfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightiv ( GLenum light , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glLightiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightfv ( GLenum light , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightfv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetLightfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetLightfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetLightiv ( GLenum light , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetLightiv (
+		JNIEnv *env, jobject obj,
+		jint light,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetLightiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetLightiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) light,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glLightModelf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeli ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeli (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glLightModeli", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModelfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModelfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glLightModelfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glLightModelfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLightModeliv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLightModeliv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glLightModeliv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glLightModeliv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialf ( GLenum face , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialf (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glMaterialf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMateriali ( GLenum face , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMateriali (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glMateriali", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialfv ( GLenum face , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glMaterialfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMaterialiv ( GLenum face , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glMaterialiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialfv ( GLenum face , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialfv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMaterialfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMaterialfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMaterialiv ( GLenum face , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMaterialiv (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMaterialiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMaterialiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorMaterial ( GLenum face , GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorMaterial (
+		JNIEnv *env, jobject obj,
+		jint face,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum))
+				getGLProcAddressHelper("glColorMaterial", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) face,
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelZoom ( GLfloat xfactor , GLfloat yfactor ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelZoom (
+		JNIEnv *env, jobject obj,
+		jfloat xfactor,
+		jfloat yfactor)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPixelZoom", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) xfactor,
+			(GLfloat) yfactor
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStoref ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStoref (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelStoref", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelStorei ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelStorei (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelStorei", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPixelTransferf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelTransferi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelTransferi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glPixelTransferi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapfv ( GLenum map , GLint mapsize , const GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLfloat *))
+				getGLProcAddressHelper("glPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapfv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLfloat *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapuiv ( GLenum map , GLint mapsize , const GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLuint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLuint *))
+				getGLProcAddressHelper("glPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapuiv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLuint *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPixelMapusv ( GLenum map , GLint mapsize , const GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jint mapsize,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, const GLushort *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, const GLushort *))
+				getGLProcAddressHelper("glPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, values, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPixelMapusv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLint) mapsize,
+			(const GLushort *) ptr2
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapfv ( GLenum map , GLfloat * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapfv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetPixelMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapfv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLfloat *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapuiv ( GLenum map , GLuint * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapuiv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint *))
+				getGLProcAddressHelper("glGetPixelMapuiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapuiv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLuint *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPixelMapusv ( GLenum map , GLushort * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPixelMapusv (
+		JNIEnv *env, jobject obj,
+		jint map,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLushort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLushort *))
+				getGLProcAddressHelper("glGetPixelMapusv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, values, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPixelMapusv arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) map,
+			(GLushort *) ptr1
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBitmap ( GLsizei width , GLsizei height , GLfloat xorig , GLfloat yorig , GLfloat xmove , GLfloat ymove , const GLubyte * bitmap ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBitmap (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jfloat xorig,
+		jfloat yorig,
+		jfloat xmove,
+		jfloat ymove,
+		jbyteArray bitmap)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))
+				getGLProcAddressHelper("glBitmap", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(bitmap!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, bitmap, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glBitmap arg: bitmap");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLfloat) xorig,
+			(GLfloat) yorig,
+			(GLfloat) xmove,
+			(GLfloat) ymove,
+			(const GLubyte *) ptr6
+		);
+
+		if(bitmap!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  bitmap, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glReadPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glReadPixels__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glReadPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glReadPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawPixels ( GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawPixels__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glDrawPixels arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyPixels ( GLint x , GLint y , GLsizei width , GLsizei height , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyPixels (
+		JNIEnv *env, jobject obj,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint type)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint, GLsizei, GLsizei, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint, GLsizei, GLsizei, GLenum))
+				getGLProcAddressHelper("glCopyPixels", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilFunc ( GLenum func , GLint ref , GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilFunc (
+		JNIEnv *env, jobject obj,
+		jint func,
+		jint ref,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLuint))
+				getGLProcAddressHelper("glStencilFunc", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) func,
+			(GLint) ref,
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilMask ( GLuint mask ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilMask (
+		JNIEnv *env, jobject obj,
+		jint mask)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glStencilMask", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) mask
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glStencilOp ( GLenum fail , GLenum zfail , GLenum zpass ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glStencilOp (
+		JNIEnv *env, jobject obj,
+		jint fail,
+		jint zfail,
+		jint zpass)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum))
+				getGLProcAddressHelper("glStencilOp", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) fail,
+			(GLenum) zfail,
+			(GLenum) zpass
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClearStencil ( GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClearStencil (
+		JNIEnv *env, jobject obj,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glClearStencil", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGend ( GLenum coord , GLenum pname , GLdouble param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGend (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdouble param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble))
+				getGLProcAddressHelper("glTexGend", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenf ( GLenum coord , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenf (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexGenf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeni ( GLenum coord , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeni (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexGeni", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGendv ( GLenum coord , GLenum pname , const GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLdouble *))
+				getGLProcAddressHelper("glTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGendv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGenfv ( GLenum coord , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGenfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexGeniv ( GLenum coord , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexGeniv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGendv ( GLenum coord , GLenum pname , GLdouble * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGendv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetTexGendv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGendv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLdouble *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGenfv ( GLenum coord , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGenfv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexGenfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGenfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexGeniv ( GLenum coord , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexGeniv (
+		JNIEnv *env, jobject obj,
+		jint coord,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexGeniv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexGeniv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) coord,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexEnvf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvi ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvi (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexEnvi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnvfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexEnvfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexEnviv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexEnviv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnvfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnvfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexEnvfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexEnvfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexEnviv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexEnviv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexEnviv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexEnviv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterf ( GLenum target , GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glTexParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteri ( GLenum target , GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glTexParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glTexParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetTexParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameterfv ( GLenum target , GLint level , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetTexLevelParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetTexLevelParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLfloat *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexLevelParameteriv ( GLenum target , GLint level , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexLevelParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint *))
+				getGLProcAddressHelper("glGetTexLevelParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, params, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetTexLevelParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) pname,
+			(GLint *) ptr3
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage1D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jbyte *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jshort *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jint *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jboolean *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage1D__IIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jlong *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glTexImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr7
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage2D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jshort *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jint *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jfloat *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jboolean *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jlong *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetTexImage ( GLenum target , GLint level , GLenum format , GLenum type , GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetTexImage__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetTexImage", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetTexImage arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTextures ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGenTextures arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTextures ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glDeleteTextures arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTexture ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTexture (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTextures ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTextures (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTextures", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPrioritizeTextures arg: textures");
+			}
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPrioritizeTextures arg: priorities");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResident ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResident (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResident", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glAreTexturesResident arg: textures");
+			}
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glAreTexturesResident arg: residences");
+			}
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTexture ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTexture (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTexture", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLsizei width , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage1D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glTexSubImage1D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jshort *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jint *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jfloat *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jboolean *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage2D__IIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jlong *ptr8 = NULL;
+		static int isWarned8 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr8 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray8);
+			if( isCopiedArray8 == JNI_TRUE && isWarned8==0 ) {
+				isWarned8=1;
+				printf("COPY by glTexSubImage2D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr8
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr8, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage1D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexImage2D ( GLenum target , GLint level , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height , GLint border ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height,
+		jint border)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))
+				getGLProcAddressHelper("glCopyTexImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLint) border
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage1D ( GLenum target , GLint level , GLint xoffset , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage2D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint stride , GLint order , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint stride,
+		jint order,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, points, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glMap1d arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLdouble *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap1f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint stride , GLint order , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap1f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint stride,
+		jint order,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, points, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glMap1f arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) stride,
+			(GLint) order,
+			(const GLfloat *) ptr5
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2d ( GLenum target , GLdouble u1 , GLdouble u2 , GLint ustride , GLint uorder , GLdouble v1 , GLdouble v2 , GLint vstride , GLint vorder , const GLdouble * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2d (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble u1,
+		jdouble u2,
+		jint ustride,
+		jint uorder,
+		jdouble v1,
+		jdouble v2,
+		jint vstride,
+		jint vorder,
+		jdoubleArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))
+				getGLProcAddressHelper("glMap2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, points, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glMap2d arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLdouble) v1,
+			(GLdouble) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLdouble *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMap2f ( GLenum target , GLfloat u1 , GLfloat u2 , GLint ustride , GLint uorder , GLfloat v1 , GLfloat v2 , GLint vstride , GLint vorder , const GLfloat * points ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMap2f (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat u1,
+		jfloat u2,
+		jint ustride,
+		jint uorder,
+		jfloat v1,
+		jfloat v2,
+		jint vstride,
+		jint vorder,
+		jfloatArray points)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))
+				getGLProcAddressHelper("glMap2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(points!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, points, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glMap2f arg: points");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) ustride,
+			(GLint) uorder,
+			(GLfloat) v1,
+			(GLfloat) v2,
+			(GLint) vstride,
+			(GLint) vorder,
+			(const GLfloat *) ptr9
+		);
+
+		if(points!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  points, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapdv ( GLenum target , GLenum query , GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapdv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLdouble *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLdouble *))
+				getGLProcAddressHelper("glGetMapdv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapdv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLdouble *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapfv ( GLenum target , GLenum query , GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMapfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapfv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLfloat *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMapiv ( GLenum target , GLenum query , GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMapiv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint query,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMapiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, v, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMapiv arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) query,
+			(GLint *) ptr2
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1d ( GLdouble u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1d (
+		JNIEnv *env, jobject obj,
+		jdouble u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble))
+				getGLProcAddressHelper("glEvalCoord1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1f ( GLfloat u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1f (
+		JNIEnv *env, jobject obj,
+		jfloat u)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glEvalCoord1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord1dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord1dv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord1fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord1fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord1fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord1fv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2d ( GLdouble u , GLdouble v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2d (
+		JNIEnv *env, jobject obj,
+		jdouble u,
+		jdouble v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLdouble, GLdouble))
+				getGLProcAddressHelper("glEvalCoord2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLdouble) u,
+			(GLdouble) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2f ( GLfloat u , GLfloat v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2f (
+		JNIEnv *env, jobject obj,
+		jfloat u,
+		jfloat v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glEvalCoord2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) u,
+			(GLfloat) v
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2dv ( const GLdouble * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2dv (
+		JNIEnv *env, jobject obj,
+		jdoubleArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLdouble *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jdouble *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLdouble *))
+				getGLProcAddressHelper("glEvalCoord2dv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetDoubleArrayElements(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord2dv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLdouble *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalCoord2fv ( const GLfloat * u ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalCoord2fv (
+		JNIEnv *env, jobject obj,
+		jfloatArray u)
+	{
+		static void (CALLBACK *__func_ptr__)(const GLfloat *) = NULL;
+		jboolean isCopiedArray0 = JNI_FALSE;
+		jfloat *ptr0 = NULL;
+		static int isWarned0 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(const GLfloat *))
+				getGLProcAddressHelper("glEvalCoord2fv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(u!=NULL)
+		{
+			ptr0 = (*env)->GetFloatArrayElements(env, u, &isCopiedArray0);
+			if( isCopiedArray0 == JNI_TRUE && isWarned0==0 ) {
+				isWarned0=1;
+				printf("COPY by glEvalCoord2fv arg: u");
+			}
+		}
+		__func_ptr__ (
+			(const GLfloat *) ptr0
+		);
+
+		if(u!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  u, ptr0, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1d ( GLint un , GLdouble u1 , GLdouble u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid1d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid1f ( GLint un , GLfloat u1 , GLfloat u2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid1f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid1f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2d ( GLint un , GLdouble u1 , GLdouble u2 , GLint vn , GLdouble v1 , GLdouble v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2d (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jdouble u1,
+		jdouble u2,
+		jint vn,
+		jdouble v1,
+		jdouble v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMapGrid2d", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLdouble) u1,
+			(GLdouble) u2,
+			(GLint) vn,
+			(GLdouble) v1,
+			(GLdouble) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMapGrid2f ( GLint un , GLfloat u1 , GLfloat u2 , GLint vn , GLfloat v1 , GLfloat v2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMapGrid2f (
+		JNIEnv *env, jobject obj,
+		jint un,
+		jfloat u1,
+		jfloat u2,
+		jint vn,
+		jfloat v1,
+		jfloat v2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMapGrid2f", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) un,
+			(GLfloat) u1,
+			(GLfloat) u2,
+			(GLint) vn,
+			(GLfloat) v1,
+			(GLfloat) v2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint1 ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint1 (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glEvalPoint1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalPoint2 ( GLint i , GLint j ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalPoint2 (
+		JNIEnv *env, jobject obj,
+		jint i,
+		jint j)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLint))
+				getGLProcAddressHelper("glEvalPoint2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i,
+			(GLint) j
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh1 ( GLenum mode , GLint i1 , GLint i2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh1 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh1", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEvalMesh2 ( GLenum mode , GLint i1 , GLint i2 , GLint j1 , GLint j2 ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEvalMesh2 (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint i1,
+		jint i2,
+		jint j1,
+		jint j2)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glEvalMesh2", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) i1,
+			(GLint) i2,
+			(GLint) j1,
+			(GLint) j2
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogf ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogf (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glFogf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogi ( GLenum pname , GLint param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogi (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jint param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glFogi", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLint) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogfv ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogfv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glFogfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glFogfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFogiv ( GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFogiv (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glFogiv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glFogiv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLint *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glFeedbackBuffer ( GLsizei size , GLenum type , GLfloat * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glFeedbackBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jfloatArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLenum, GLfloat *))
+				getGLProcAddressHelper("glFeedbackBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, buffer, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glFeedbackBuffer arg: buffer");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLenum) type,
+			(GLfloat *) ptr2
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  buffer, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPassThrough ( GLfloat token ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPassThrough (
+		JNIEnv *env, jobject obj,
+		jfloat token)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat))
+				getGLProcAddressHelper("glPassThrough", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) token
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSelectBuffer ( GLsizei size , GLuint * buffer ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSelectBuffer (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jintArray buffer)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glSelectBuffer", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(buffer!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, buffer, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glSelectBuffer arg: buffer");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) size,
+			(GLuint *) ptr1
+		);
+
+		if(buffer!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  buffer, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glInitNames ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glInitNames (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glInitNames", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLoadName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLoadName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glLoadName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPushName ( GLuint name ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPushName (
+		JNIEnv *env, jobject obj,
+		jint name)
+	{
+		static void (CALLBACK *__func_ptr__)(GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glPushName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLuint) name
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPopName ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPopName (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glPopName", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawRangeElements ( GLenum mode , GLuint start , GLuint end , GLsizei count , GLenum type , const GLvoid * indices ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbyteArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jshortArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jintArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jfloatArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jdoubleArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jbooleanArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawRangeElements__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint start,
+		jint end,
+		jint count,
+		jint type,
+		jlongArray indices)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glDrawRangeElements", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(indices!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, indices, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glDrawRangeElements arg: indices");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLuint) start,
+			(GLuint) end,
+			(GLsizei) count,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(indices!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  indices, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3D ( GLenum target , GLint level , GLint internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jbyte *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jshort *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jint *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jboolean *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3D__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jlong *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jbyte *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jshort *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jint *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jfloat *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jdouble *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jboolean *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3D__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jlong *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3D arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3D ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTable ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTable ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTable__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTable arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glColorTableParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glColorTableParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorSubTable ( GLenum target , GLsizei start , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorSubTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorSubTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyColorTable ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyColorTable (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTable ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTable__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTable", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTable arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquation ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquation (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquation", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColor ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColor (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColor", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glHistogram ( GLenum target , GLsizei width , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glHistogram (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint width,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLenum, GLboolean))
+				getGLProcAddressHelper("glHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) width,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetHistogram ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetHistogram (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogram ( GLenum target , GLboolean reset , GLenum format , GLenum type , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogram__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint type,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetHistogram", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetHistogram arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetHistogramParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetHistogramParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetHistogramParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetHistogramParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetHistogramParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetHistogramParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMinmax ( GLenum target , GLenum internalformat , GLboolean sink ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMinmax (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jboolean sink)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLboolean) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLboolean))
+				getGLProcAddressHelper("glMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLboolean) sink
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glResetMinmax ( GLenum target ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glResetMinmax (
+		JNIEnv *env, jobject obj,
+		jint target)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glResetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmax ( GLenum target , GLboolean reset , GLenum format , GLenum types , GLvoid * values ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbyteArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jshortArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jintArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jfloatArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jdoubleArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jbooleanArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmax__IZII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jboolean reset,
+		jint format,
+		jint types,
+		jlongArray values)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLboolean, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLboolean, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetMinmax", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(values!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, values, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetMinmax arg: values");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLboolean) reset,
+			(GLenum) format,
+			(GLenum) types,
+			(GLvoid *) ptr4
+		);
+
+		if(values!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  values, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetMinmaxParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMinmaxParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetMinmaxParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetMinmaxParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetMinmaxParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetMinmaxParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter1D ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter1D__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, image, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glConvolutionFilter1D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionFilter2D__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, image, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glConvolutionFilter2D arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr6, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterf ( GLenum target , GLenum pname , GLfloat params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterf (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloat params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat))
+				getGLProcAddressHelper("glConvolutionParameterf", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameterfv ( GLenum target , GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLfloat *))
+				getGLProcAddressHelper("glConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glConvolutionParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteri ( GLenum target , GLenum pname , GLint params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteri (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jint params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint))
+				getGLProcAddressHelper("glConvolutionParameteri", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint) params
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glConvolutionParameteriv ( GLenum target , GLenum pname , const GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, const GLint *))
+				getGLProcAddressHelper("glConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glConvolutionParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(const GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter1D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter1D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter1D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyConvolutionFilter2D ( GLenum target , GLenum internalformat , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyConvolutionFilter2D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyConvolutionFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionFilter ( GLenum target , GLenum format , GLenum type , GLvoid * image ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionFilter__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray image)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetConvolutionFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(image!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, image, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetConvolutionFilter arg: image");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(image!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  image, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameterfv ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameterfv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetConvolutionParameterfv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetConvolutionParameterfv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetConvolutionParameteriv ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetConvolutionParameteriv (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetConvolutionParameteriv", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetConvolutionParameteriv arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glSeparableFilter2D ( GLenum target , GLenum internalformat , GLsizei width , GLsizei height , GLenum format , GLenum type , const GLvoid * row , const GLvoid * column ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jbyte *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jbyte *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetByteArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jshort *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jshort *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetShortArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jint *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jint *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetIntArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jfloat *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jboolean *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jboolean *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetBooleanArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glSeparableFilter2D__IIIIII_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *) = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jlong *ptr6 = NULL;
+		static int isWarned6 = 0;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jlong *ptr7 = NULL;
+		static int isWarned7 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *))
+				getGLProcAddressHelper("glSeparableFilter2D", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, row, &isCopiedArray6);
+			if( isCopiedArray6 == JNI_TRUE && isWarned6==0 ) {
+				isWarned6=1;
+				printf("COPY by glSeparableFilter2D arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr7 = (*env)->GetLongArrayElements(env, column, &isCopiedArray7);
+			if( isCopiedArray7 == JNI_TRUE && isWarned7==0 ) {
+				isWarned7=1;
+				printf("COPY by glSeparableFilter2D arg: column");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr6,
+			(const GLvoid *) ptr7
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr6, JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr7, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetSeparableFilter ( GLenum target , GLenum format , GLenum type , GLvoid * row , GLvoid * column , GLvoid * span ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3B_3B_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray row,
+		jbyteArray column,
+		jbyteArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3S_3S_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray row,
+		jshortArray column,
+		jshortArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3I_3I_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray row,
+		jintArray column,
+		jintArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3F_3F_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray row,
+		jfloatArray column,
+		jfloatArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3D_3D_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray row,
+		jdoubleArray column,
+		jdoubleArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3Z_3Z_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray row,
+		jbooleanArray column,
+		jbooleanArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetSeparableFilter__III_3J_3J_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray row,
+		jlongArray column,
+		jlongArray span)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *))
+				getGLProcAddressHelper("glGetSeparableFilter", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(row!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, row, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetSeparableFilter arg: row");
+			}
+		}
+		if(column!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, column, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glGetSeparableFilter arg: column");
+			}
+		}
+		if(span!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, span, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glGetSeparableFilter arg: span");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3,
+			(GLvoid *) ptr4,
+			(GLvoid *) ptr5
+		);
+
+		if(row!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  row, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(column!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  column, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(span!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  span, ptr5, (isCopiedArray5 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendColorEXT ( GLclampf red , GLclampf green , GLclampf blue , GLclampf alpha ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendColorEXT (
+		JNIEnv *env, jobject obj,
+		jfloat red,
+		jfloat green,
+		jfloat blue,
+		jfloat alpha)
+	{
+		static void (CALLBACK *__func_ptr__)(GLclampf, GLclampf, GLclampf, GLclampf) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLclampf, GLclampf, GLclampf, GLclampf))
+				getGLProcAddressHelper("glBlendColorEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLclampf) red,
+			(GLclampf) green,
+			(GLclampf) blue,
+			(GLclampf) alpha
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPolygonOffsetEXT ( GLfloat factor , GLfloat bias ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPolygonOffsetEXT (
+		JNIEnv *env, jobject obj,
+		jfloat factor,
+		jfloat bias)
+	{
+		static void (CALLBACK *__func_ptr__)(GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLfloat, GLfloat))
+				getGLProcAddressHelper("glPolygonOffsetEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLfloat) factor,
+			(GLfloat) bias
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexImage3DEXT ( GLenum target , GLint level , GLenum internalFormat , GLsizei width , GLsizei height , GLsizei depth , GLint border , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jbyte *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jshort *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jint *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jfloat *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jdouble *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jboolean *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexImage3DEXT__IIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint internalFormat,
+		jint width,
+		jint height,
+		jint depth,
+		jint border,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray9 = JNI_FALSE;
+		jlong *ptr9 = NULL;
+		static int isWarned9 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr9 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray9);
+			if( isCopiedArray9 == JNI_TRUE && isWarned9==0 ) {
+				isWarned9=1;
+				printf("COPY by glTexImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLenum) internalFormat,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLint) border,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr9
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr9, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLsizei width , GLsizei height , GLsizei depth , GLenum format , GLenum type , const GLvoid * pixels ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbyteArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jbyte *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetByteArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jshortArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jshort *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetShortArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jintArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jint *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetIntArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jfloatArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jfloat *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetFloatArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jdoubleArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jdouble *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetDoubleArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jbooleanArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jboolean *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetBooleanArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexSubImage3DEXT__IIIIIIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint width,
+		jint height,
+		jint depth,
+		jint format,
+		jint type,
+		jlongArray pixels)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray10 = JNI_FALSE;
+		jlong *ptr10 = NULL;
+		static int isWarned10 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(pixels!=NULL)
+		{
+			ptr10 = (*env)->GetLongArrayElements(env, pixels, &isCopiedArray10);
+			if( isCopiedArray10 == JNI_TRUE && isWarned10==0 ) {
+				isWarned10=1;
+				printf("COPY by glTexSubImage3DEXT arg: pixels");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLsizei) width,
+			(GLsizei) height,
+			(GLsizei) depth,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr10
+		);
+
+		if(pixels!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  pixels, ptr10, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glCopyTexSubImage3DEXT ( GLenum target , GLint level , GLint xoffset , GLint yoffset , GLint zoffset , GLint x , GLint y , GLsizei width , GLsizei height ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glCopyTexSubImage3DEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint level,
+		jint xoffset,
+		jint yoffset,
+		jint zoffset,
+		jint x,
+		jint y,
+		jint width,
+		jint height)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))
+				getGLProcAddressHelper("glCopyTexSubImage3DEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) level,
+			(GLint) xoffset,
+			(GLint) yoffset,
+			(GLint) zoffset,
+			(GLint) x,
+			(GLint) y,
+			(GLsizei) width,
+			(GLsizei) height
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGenTexturesEXT ( GLsizei n , GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGenTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLuint *))
+				getGLProcAddressHelper("glGenTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGenTexturesEXT arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDeleteTexturesEXT ( GLsizei n , const GLuint * textures ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDeleteTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *))
+				getGLProcAddressHelper("glDeleteTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glDeleteTexturesEXT arg: textures");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBindTextureEXT ( GLenum target , GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBindTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLuint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLuint))
+				getGLProcAddressHelper("glBindTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLuint) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPrioritizeTexturesEXT ( GLsizei n , const GLuint * textures , const GLclampf * priorities ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPrioritizeTexturesEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jfloatArray priorities)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, const GLclampf *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, const GLuint *, const GLclampf *))
+				getGLProcAddressHelper("glPrioritizeTexturesEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPrioritizeTexturesEXT arg: textures");
+			}
+		}
+		if(priorities!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, priorities, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glPrioritizeTexturesEXT arg: priorities");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(const GLclampf *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(priorities!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  priorities, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glAreTexturesResidentEXT ( GLsizei n , const GLuint * textures , GLboolean * residences ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glAreTexturesResidentEXT (
+		JNIEnv *env, jobject obj,
+		jint n,
+		jintArray textures,
+		jbooleanArray residences)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLsizei, const GLuint *, GLboolean *) = NULL;
+		jboolean ret;
+
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLsizei, const GLuint *, GLboolean *))
+				getGLProcAddressHelper("glAreTexturesResidentEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		if(textures!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, textures, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glAreTexturesResidentEXT arg: textures");
+			}
+		}
+		if(residences!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, residences, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glAreTexturesResidentEXT arg: residences");
+			}
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLsizei) n,
+			(const GLuint *) ptr1,
+			(GLboolean *) ptr2
+		);
+
+		if(textures!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  textures, ptr1, JNI_ABORT);
+		}
+		if(residences!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  residences, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLboolean glIsTextureEXT ( GLuint texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT jboolean JNICALL
+	Java_gl4java_GLFuncJauJNI_glIsTextureEXT (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static jboolean (CALLBACK *__func_ptr__)(GLuint) = NULL;
+		jboolean ret;
+
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (jboolean (CALLBACK *)(GLuint))
+				getGLProcAddressHelper("glIsTextureEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return 0;
+		}
+		ret = (jboolean) __func_ptr__ (
+			(GLuint) texture
+		);
+
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glVertexPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glVertexPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glVertexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glVertexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glNormalPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glNormalPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glNormalPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glNormalPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glColorPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glColorPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glIndexPointerEXT ( GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glIndexPointerEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glIndexPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glIndexPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr3
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glTexCoordPointerEXT ( GLint size , GLenum type , GLsizei stride , GLsizei count , const GLvoid * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3B (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbyteArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jbyte *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3S (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jshortArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jshort *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetShortArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3I (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jintArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3F (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jfloatArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3D (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jdoubleArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jdouble *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jboolean *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glTexCoordPointerEXT__IIII_3J (
+		JNIEnv *env, jobject obj,
+		jint size,
+		jint type,
+		jint stride,
+		jint count,
+		jlongArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *) = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jlong *ptr4 = NULL;
+		static int isWarned4 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *))
+				getGLProcAddressHelper("glTexCoordPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr4 = (*env)->GetLongArrayElements(env, ptr, &isCopiedArray4);
+			if( isCopiedArray4 == JNI_TRUE && isWarned4==0 ) {
+				isWarned4=1;
+				printf("COPY by glTexCoordPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLint) size,
+			(GLenum) type,
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLvoid *) ptr4
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  ptr, ptr4, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glEdgeFlagPointerEXT ( GLsizei stride , GLsizei count , const GLboolean * ptr ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glEdgeFlagPointerEXT (
+		JNIEnv *env, jobject obj,
+		jint stride,
+		jint count,
+		jbooleanArray ptr)
+	{
+		static void (CALLBACK *__func_ptr__)(GLsizei, GLsizei, const GLboolean *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLsizei, GLsizei, const GLboolean *))
+				getGLProcAddressHelper("glEdgeFlagPointerEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(ptr!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, ptr, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glEdgeFlagPointerEXT arg: ptr");
+			}
+		}
+		__func_ptr__ (
+			(GLsizei) stride,
+			(GLsizei) count,
+			(const GLboolean *) ptr2
+		);
+
+		if(ptr!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  ptr, ptr2, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetPointervEXT ( GLenum pname , void * * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3B (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbyteArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3S (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jshortArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3I (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3F (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3D (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jdoubleArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3Z (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jbooleanArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetPointervEXT__I_3_3J (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jlongArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, void **) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, void **))
+				getGLProcAddressHelper("glGetPointervEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glGetPointervEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(void **) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  params, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glArrayElementEXT ( GLint i ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glArrayElementEXT (
+		JNIEnv *env, jobject obj,
+		jint i)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint))
+				getGLProcAddressHelper("glArrayElementEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) i
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glDrawArraysEXT ( GLenum mode , GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glDrawArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint mode,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLsizei))
+				getGLProcAddressHelper("glDrawArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode,
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glBlendEquationEXT ( GLenum mode ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glBlendEquationEXT (
+		JNIEnv *env, jobject obj,
+		jint mode)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glBlendEquationEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) mode
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfEXT ( GLenum pname , GLfloat param ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloat param)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glPointParameterfEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(GLfloat) param
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glPointParameterfvEXT ( GLenum pname , const GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glPointParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glPointParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glPointParameterfvEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) pname,
+			(const GLfloat *) ptr1
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorTableEXT ( GLenum target , GLenum internalformat , GLsizei width , GLenum format , GLenum type , const GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint internalformat,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, table, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) internalformat,
+			(GLsizei) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glColorSubTableEXT ( GLenum target , GLsizei start , GLsizei count , GLenum format , GLenum type , const GLvoid * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jbyte *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jshort *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jint *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jfloat *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jdouble *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jboolean *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glColorSubTableEXT__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint start,
+		jint count,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) = NULL;
+		jboolean isCopiedArray5 = JNI_FALSE;
+		jlong *ptr5 = NULL;
+		static int isWarned5 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+				getGLProcAddressHelper("glColorSubTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, &isCopiedArray5);
+			if( isCopiedArray5 == JNI_TRUE && isWarned5==0 ) {
+				isWarned5=1;
+				printf("COPY by glColorSubTableEXT arg: data");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLsizei) start,
+			(GLsizei) count,
+			(GLenum) format,
+			(GLenum) type,
+			(const GLvoid *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableEXT ( GLenum target , GLenum format , GLenum type , GLvoid * table ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbyteArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jbyte *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetByteArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jshortArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jshort *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetShortArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jintArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jint *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jfloatArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jfloat *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetFloatArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jdoubleArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jdouble *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jbooleanArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jboolean *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetBooleanArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableEXT__III_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint format,
+		jint type,
+		jlongArray table)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLenum, GLvoid *) = NULL;
+		jboolean isCopiedArray3 = JNI_FALSE;
+		jlong *ptr3 = NULL;
+		static int isWarned3 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLenum, GLvoid *))
+				getGLProcAddressHelper("glGetColorTableEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(table!=NULL)
+		{
+			ptr3 = (*env)->GetLongArrayElements(env, table, &isCopiedArray3);
+			if( isCopiedArray3 == JNI_TRUE && isWarned3==0 ) {
+				isWarned3=1;
+				printf("COPY by glGetColorTableEXT arg: table");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) format,
+			(GLenum) type,
+			(GLvoid *) ptr3
+		);
+
+		if(table!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  table, ptr3, (isCopiedArray3 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterfvEXT ( GLenum target , GLenum pname , GLfloat * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterfvEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jfloatArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLfloat *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLfloat *))
+				getGLProcAddressHelper("glGetColorTableParameterfvEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterfvEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLfloat *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glGetColorTableParameterivEXT ( GLenum target , GLenum pname , GLint * params ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glGetColorTableParameterivEXT (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint pname,
+		jintArray params)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLenum, GLint *) = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+		static int isWarned2 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLenum, GLint *))
+				getGLProcAddressHelper("glGetColorTableParameterivEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(params!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, params, &isCopiedArray2);
+			if( isCopiedArray2 == JNI_TRUE && isWarned2==0 ) {
+				isWarned2=1;
+				printf("COPY by glGetColorTableParameterivEXT arg: params");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLenum) pname,
+			(GLint *) ptr2
+		);
+
+		if(params!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  params, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glLockArraysEXT ( GLint first , GLsizei count ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glLockArraysEXT (
+		JNIEnv *env, jobject obj,
+		jint first,
+		jint count)
+	{
+		static void (CALLBACK *__func_ptr__)(GLint, GLsizei) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLint, GLsizei))
+				getGLProcAddressHelper("glLockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLint) first,
+			(GLsizei) count
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glUnlockArraysEXT ( void ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glUnlockArraysEXT (
+		JNIEnv *env, jobject obj)
+	{
+		static void (CALLBACK *__func_ptr__)() = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)())
+				getGLProcAddressHelper("glUnlockArraysEXT", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glClientActiveTextureARB ( GLenum texture ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glClientActiveTextureARB (
+		JNIEnv *env, jobject obj,
+		jint texture)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum))
+				getGLProcAddressHelper("glClientActiveTextureARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) texture
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dARB ( GLenum target , GLdouble s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord1dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord1dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fARB ( GLenum target , GLfloat s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord1fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord1fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1iARB ( GLenum target , GLint s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint))
+				getGLProcAddressHelper("glMultiTexCoord1iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord1ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1sARB ( GLenum target , GLshort s ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord1sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord1svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord1svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord1svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord1svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dARB ( GLenum target , GLdouble s , GLdouble t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord2dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord2dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fARB ( GLenum target , GLfloat s , GLfloat t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord2fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord2fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2iARB ( GLenum target , GLint s , GLint t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord2iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord2ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2sARB ( GLenum target , GLshort s , GLshort t ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord2sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord2svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord2svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord2svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord2svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord3dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord3dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord3fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord3fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3iARB ( GLenum target , GLint s , GLint t , GLint r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord3iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord3ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3sARB ( GLenum target , GLshort s , GLshort t , GLshort r ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord3sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord3svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord3svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord3svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord3svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dARB ( GLenum target , GLdouble s , GLdouble t , GLdouble r , GLdouble q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdouble s,
+		jdouble t,
+		jdouble r,
+		jdouble q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))
+				getGLProcAddressHelper("glMultiTexCoord4dARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLdouble) s,
+			(GLdouble) t,
+			(GLdouble) r,
+			(GLdouble) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4dvARB ( GLenum target , const GLdouble * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4dvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jdoubleArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLdouble *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLdouble *))
+				getGLProcAddressHelper("glMultiTexCoord4dvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4dvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLdouble *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fARB ( GLenum target , GLfloat s , GLfloat t , GLfloat r , GLfloat q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloat s,
+		jfloat t,
+		jfloat r,
+		jfloat q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))
+				getGLProcAddressHelper("glMultiTexCoord4fARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLfloat) s,
+			(GLfloat) t,
+			(GLfloat) r,
+			(GLfloat) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4fvARB ( GLenum target , const GLfloat * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4fvARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jfloatArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLfloat *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLfloat *))
+				getGLProcAddressHelper("glMultiTexCoord4fvARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4fvARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLfloat *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4iARB ( GLenum target , GLint s , GLint t , GLint r , GLint q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4iARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint s,
+		jint t,
+		jint r,
+		jint q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLint, GLint, GLint, GLint) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLint, GLint, GLint, GLint))
+				getGLProcAddressHelper("glMultiTexCoord4iARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLint) s,
+			(GLint) t,
+			(GLint) r,
+			(GLint) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4ivARB ( GLenum target , const GLint * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4ivARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jintArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLint *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLint *))
+				getGLProcAddressHelper("glMultiTexCoord4ivARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4ivARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLint *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4sARB ( GLenum target , GLshort s , GLshort t , GLshort r , GLshort q ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4sARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshort s,
+		jshort t,
+		jshort r,
+		jshort q)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, GLshort, GLshort, GLshort, GLshort) = NULL;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, GLshort, GLshort, GLshort, GLshort))
+				getGLProcAddressHelper("glMultiTexCoord4sARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(GLshort) s,
+			(GLshort) t,
+			(GLshort) r,
+			(GLshort) q
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void glMultiTexCoord4svARB ( GLenum target , const GLshort * v ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLFuncJauJNI_glMultiTexCoord4svARB (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jshortArray v)
+	{
+		static void (CALLBACK *__func_ptr__)(GLenum, const GLshort *) = NULL;
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+		static int isWarned1 = 0;
+
+		if(__func_ptr__==NULL) {
+			__func_ptr__ = (void (CALLBACK *)(GLenum, const GLshort *))
+				getGLProcAddressHelper("glMultiTexCoord4svARB", NULL, 1, 0);
+			if(__func_ptr__==NULL)
+				return;
+		}
+		if(v!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, v, &isCopiedArray1);
+			if( isCopiedArray1 == JNI_TRUE && isWarned1==0 ) {
+				isWarned1=1;
+				printf("COPY by glMultiTexCoord4svARB arg: v");
+			}
+		}
+		__func_ptr__ (
+			(GLenum) target,
+			(const GLshort *) ptr1
+		);
+
+		if(v!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  v, ptr1, JNI_ABORT);
+		}
+	}
+
+/* C2J Parser Version 1.4 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGL_Win32.c b/CNativeCode/OpenGL_Win32.c
new file mode 100755
index 0000000..a667ce0
--- /dev/null
+++ b/CNativeCode/OpenGL_Win32.c
@@ -0,0 +1,1110 @@
+/*

+ * Original Author: Leo Chan -- 1995

+ *

+ * Adam King 1997

+ *		Ported to Win32 from X

+ *

+ * This file takes care of the C implementation of finding the correct

+ * Win32 window, assigning an OpenGL graphics context to it, storing that

+ * graphics context in the java class data structure.

+ *

+ * also contains the use() and swap() functions for double buffering

+ *

+ * September 12, 1997	- Adam King

+ *		- Added support for rendering directly into a Canvas ( BIG rewrite )

+ */

+#ifdef _WIN32_

+	#include "winstuff.h"

+#endif

+

+#include <stdio.h>

+#include <jni.h>

+

+/*

+void gl4java_bind_ext(int verbose);

+*/

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+#include <GL\gl.h>

+#include <gl\glu.h>

+#include <wingdi.h>

+

+static jboolean verbose = JNI_FALSE;

+

+// Color Palette handle

+static HPALETTE hPalette = NULL;

+static HGLRC tempRC;

+

+// Set Pixel Format function - forward declaration

+static void SetDCPixelFormat(HDC hDC, jboolean doubleBuffer, jboolean stereo, jint stencilBits, jboolean offScreenRenderer);

+static HPALETTE GetOpenGLPalette(HDC hDC);

+static HGLRC get_GC( HDC *hDC, jboolean doubleBuffer, jboolean stereo, jint stencilBits, HGLRC shareWith, jboolean offScreenRenderer,

+					 int width, int height, HBITMAP *pix);

+

+static int PixelFormatDescriptorFromDc( HDC Dc, PIXELFORMATDESCRIPTOR *Pfd );

+static const char * GetTextualPixelFormatByHDC(HDC hdc);

+static const char * GetTextualPixelFormatByPFD(PIXELFORMATDESCRIPTOR *ppfd, int format);

+

+/* testJavaGLTypes does important implementation plattformspecific checks:

+ *

+ * o do fit X11-Vars in jint (because GLContext stores 'em like that)

+ * o do fit the JNI <-> GL Variables-Type Mapping

+ * o IF ERROR OR VERBOSE -> DUMP JNI,GL Type-Length

+ */

+jboolean testJavaGLTypes(jboolean verbose);

+

+/* testX11Java does important implementation plattformspecific checks:

+ *

+ * o do fit X11-Vars in jint (because GLContext stores 'em like that)

+ */

+jboolean testWin32Java(void);

+

+static void setupDIB(HDC hDCOrig, HDC hDC, HBITMAP * hBitmap, int width, int height);

+static void resizeDIB(HDC hDC, HBITMAP *hOldBitmap, HBITMAP *hBitmap);

+static void setupPalette(HDC hDC);

+

+

+JNIEXPORT jboolean JNICALL

+Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj )

+{

+    jboolean ret = JNI_TRUE;

+

+    jclass cls = 0;

+    jfieldID fpixmapHandle=0;

+    jfieldID foffScreenRenderer;

+    jfieldID faccumSize=0;

+    jfieldID fwindowHandle=0, fpData=0, fdoubleBuffer, fstereoView, fstencilBits;

+    jfieldID fverbose=0;

+    jfieldID fglContext=0;

+    jfieldID fshareWith=0;

+    jfieldID fcreatewinw = 0, fcreatewinh = 0;

+

+    /* these variables will be mapped in the java-object ! */

+    jboolean joffScreenRenderer=JNI_FALSE;

+	jboolean jdoubleBuffer=JNI_TRUE;

+	jboolean jstereoView=JNI_FALSE;

+	jint jstencilBits=0;

+    jint jaccumSize=0;

+    HDC thisWin;

+    HGLRC gc;

+    jint pData=0;

+	HGLRC shareWith=NULL;

+    jint jcreatewinw = 0, jcreatewinh = 0;

+    HBITMAP pix;

+

+    PIXELFORMATDESCRIPTOR pfd;

+

+    cls = (*env)->GetObjectClass(env, obj);

+    if(cls==0)

+    {

+        fprintf(stderr,"oo0.0 cls==0\n");

+		  fflush(stderr);

+		  ret=JNI_FALSE;

+    }

+

+    if(ret==JNI_TRUE)

+    {

+	    fverbose =(*env)->GetStaticFieldID(env, cls, "gljNativeDebug", "Z");

+	    if (fverbose == 0)

+	    {

+                fprintf(stderr,"oo0.2 fverbose==0\n");

+                fflush(stderr);

+					 ret=JNI_FALSE;

+	    } else {

+		verbose = (*env)->GetStaticBooleanField(env, cls, fverbose);

+	    }

+    }

+

+    if(JNI_TRUE==verbose)

+    {

+		fprintf(stderr, "sizes:\n jint=%d\n HGLRC=%d\n HDC=%d\n",

+	  		sizeof(jint), sizeof(HGLRC), sizeof(HDC) );

+		fflush(stderr);

+    }

+

+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR WIN-TYPE FITS IN �jint� */

+    ret = testWin32Java();

+

+    ret = testJavaGLTypes(verbose);

+

+    if(ret==JNI_TRUE) {

+	    fpData = (*env)->GetFieldID(env, cls, "pData", "I");

+	    if (fpData == 0) ret= JNI_FALSE;

+	    else pData =(*env)->GetIntField(env, obj, fpData);

+    }

+    if(JNI_TRUE==verbose)

+    {

+    	fprintf(stderr, "received pData : %d\n", (int)pData);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "I");

+	    if (fwindowHandle == 0) ret= JNI_FALSE;

+    }

+

+    if(ret==JNI_TRUE) {

+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "I");

+	    if (fglContext == 0) ret= JNI_FALSE;

+    }

+

+    if(ret==JNI_TRUE) {

+	    foffScreenRenderer = 

+	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");

+	    if (foffScreenRenderer == 0) ret= JNI_FALSE;

+	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");

+	    if (fdoubleBuffer == 0) ret= JNI_FALSE;

+	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");

+	    if (fstereoView == 0) ret= JNI_FALSE;

+	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");

+	    if (fstencilBits == 0) ret= JNI_FALSE;

+	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);

+    }

+

+    if(ret==JNI_TRUE) {

+	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");

+	    if (faccumSize == 0) ret= JNI_FALSE;

+	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fcreatewinw = (*env)->GetFieldID(env, cls, "createwinw", "I");

+	    if (fcreatewinw == 0) ret= JNI_FALSE;

+	    else jcreatewinw =(*env)->GetIntField(env, obj, fcreatewinw);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fcreatewinh = (*env)->GetFieldID(env, cls, "createwinh", "I");

+	    if (fcreatewinh == 0) ret= JNI_FALSE;

+	    else jcreatewinh =(*env)->GetIntField(env, obj, fcreatewinh);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fshareWith = (*env)->GetFieldID(env, cls, "sharedGLContextNative", "I");

+	    if (fshareWith == 0) ret= JNI_FALSE;

+	    else shareWith = (HGLRC) (*env)->GetIntField(env, obj, fshareWith);

+    }

+

+    if(ret==JNI_TRUE) {

+	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "I");

+	    if (fpixmapHandle == 0) ret= JNI_FALSE;

+    }

+

+    if(joffScreenRenderer==JNI_TRUE)

+    {

+	    jdoubleBuffer = JNI_FALSE;

+    }

+

+    if(JNI_TRUE==verbose && joffScreenRenderer==JNI_TRUE)

+    {

+		fprintf(stderr,"\nGL4Java:  (USING OFFSCREEN GLPIXMAP BUFFER,\n\t forced: !doubleBuffer)\n");

+		fflush(stderr);

+    }

+

+    wglMakeCurrent(NULL, NULL);

+

+    /**

+     * with version jdk1.1.6 and later, we are able to use 

+     * the java-function straight to achieve the native window

+     * handle ....

+     *

+     * this handle is saved to pData for the windows version !

+     */

+    if( pData == 0)

+    {

+	    printf( "get_GC: Error, pData is zero\n");

+	    return JNI_FALSE;

+    }

+    if( pData != 0 )

+	    thisWin = (HDC)pData;

+

+    /* get the graphics context for this widget */

+    if( (gc = get_GC( &thisWin, jdoubleBuffer, jstereoView, jstencilBits, shareWith, 

+				      joffScreenRenderer, jcreatewinw, jcreatewinh, &pix)) == 0 )

+    {

+	    printf( "getGC error" );

+	    return JNI_FALSE;

+    }

+

+	/* fetch the states of doubleBuffer and stereo */

+    (void) PixelFormatDescriptorFromDc( thisWin, &pfd);

+

+	jdoubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER)?JNI_TRUE:JNI_FALSE;

+    if(ret==JNI_TRUE && fdoubleBuffer!=0) {

+	    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 

+	                            jdoubleBuffer);

+    }

+

+	jstencilBits = (jint)(pfd.cStencilBits);

+	if(ret==JNI_TRUE && fstencilBits!=0) {

+	    (*env)->SetIntField(env, obj, 

+				fstencilBits, (jint)jstencilBits);

+	}

+

+	jaccumSize=(jint)(pfd.cAccumRedBits+pfd.cAccumGreenBits+pfd.cAccumBlueBits+pfd.cAccumAlphaBits);

+	if(ret==JNI_TRUE && faccumSize!=0) {

+	    (*env)->SetIntField(env, obj, 

+				faccumSize, (jint)jaccumSize);

+	}

+

+    if(ret==JNI_TRUE && fwindowHandle!=0) {

+	    (*env)->SetIntField(env, obj, fwindowHandle, (jint)thisWin);

+    	 if(JNI_TRUE==verbose)

+    		fprintf(stderr, "go and set windowHandle thisWin : %d; 0x%X\n",

+         	(int)thisWin, (int)thisWin);

+    }

+

+    if(ret==JNI_TRUE && fpixmapHandle!=0) {

+	    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)pix);

+    	 if(JNI_TRUE==verbose)

+    		fprintf(stderr, "go and set pixmapHandle pix: %d; 0x%X\n",

+         	(int)pix, (int)pix);

+    }

+

+    if(ret==JNI_TRUE && fglContext !=0 ) {

+	    (*env)->SetIntField(env, obj, fglContext, (jint)gc);

+    	 if(JNI_TRUE==verbose)

+    		fprintf(stderr, "go and set gc  : %d, 0x%X\n",

+         	(int)gc, (int)gc);

+    }

+

+	/*

+	gl4java_bind_ext(JNI_TRUE==verbose);

+	*/

+

+    return ret;

+}

+

+JNIEXPORT jboolean JNICALL

+Java_gl4java_GLContext_gljMakeCurrentNative( JNIEnv *env, jobject obj,

+					     jint disp,

+					     jint thisWin,

+					     jint glContext)

+{

+	jboolean ret = JNI_TRUE;

+

+	if( !thisWin )

+	{

+	    return JNI_FALSE;

+	}

+

+	if( !glContext )

+	{

+	    return JNI_FALSE;

+	}

+

+        if ( ret==JNI_TRUE && !wglMakeCurrent((HDC)thisWin, (HGLRC)glContext) )

+        {

+    		return JNI_FALSE;

+        } 

+        return JNI_TRUE;

+}

+

+JNIEXPORT jboolean JNICALL

+Java_gl4java_GLContext_gljFreeNative( JNIEnv *env, jobject obj,

+				      jint disp,

+				      jint thisWin,

+				      jint glContext

+				    )

+{

+    (void)thisWin;

+    (void)glContext;

+    (void)disp;

+

+    if ( ! wglMakeCurrent( NULL, NULL ) )

+    {

+			fprintf(stderr, "gljFree failed\n");

+			fflush(stderr);

+			return JNI_FALSE;

+    }

+    return JNI_TRUE;

+}

+

+JNIEXPORT jboolean JNICALL

+Java_gl4java_GLContext_gljDestroyNative( JNIEnv *env, jobject obj )

+{

+	jboolean ret = JNI_TRUE;

+

+	jclass cls = 0;

+	jfieldID fwindowHandle=0, fpixmapHandle;

+	jfieldID fglContext=0;

+    jfieldID foffScreenRenderer;

+

+    jboolean joffScreenRenderer=JNI_FALSE;

+    HBITMAP pix;

+	HDC thisWin;

+	HGLRC gc;

+

+	cls = (*env)->GetObjectClass(env, obj);

+	if(cls==0)

+	{

+	    ret=JNI_FALSE;

+	}

+

+	if(ret==JNI_TRUE) {

+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "I");

+	    if (fwindowHandle == 0) ret= JNI_FALSE;

+	    else thisWin =(HDC) (*env)->GetIntField(env, obj, fwindowHandle);

+	}

+

+	if(ret==JNI_TRUE) {

+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "I");

+	    if (fglContext == 0) ret= JNI_FALSE;

+	    else gc =(HGLRC)(*env)->GetIntField(env, obj, fglContext);

+	}

+

+

+    if(ret==JNI_TRUE) {

+	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "I");

+	    if (fpixmapHandle == 0) ret= JNI_FALSE;

+	    else pix =(HBITMAP)(*env)->GetIntField(env, obj, fpixmapHandle);

+    }

+

+    if(ret==JNI_TRUE) {

+	    foffScreenRenderer = 

+	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");

+	    if (foffScreenRenderer == 0) ret= JNI_FALSE;

+	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);

+    }

+

+

+    if(ret==JNI_TRUE)

+    {

+	    if ( gc == 0 )

+	    {

+	        if(JNI_TRUE==verbose)

+			{

+				fprintf(stderr, "gljDestroy failed, GL context is 0\n");

+				fflush(stderr);

+			}

+			ret = JNI_FALSE;

+		}

+

+		if ( ret==JNI_TRUE &&  ! wglMakeCurrent( NULL, NULL ) )

+		{

+			fprintf(stderr, "gljDestroy failed (free)\n");

+			fflush(stderr);

+			ret=JNI_FALSE;

+		} else if( ret == JNI_TRUE) {

+			wglDeleteContext(gc);

+		}

+

+		if(joffScreenRenderer==JNI_TRUE)

+		{

+			if(pix!=0)

+			{

+				DeleteObject(pix);

+				pix=0;

+			}

+			if(thisWin!=0)

+			{

+				DeleteDC(thisWin);

+				thisWin=0;

+			}

+		}

+	}

+

+    if(ret==JNI_TRUE)

+    {

+	    gc = 0;

+	    thisWin = 0;

+    }

+

+    if(ret==JNI_TRUE && fwindowHandle!=0) {

+	    (*env)->SetIntField(env, obj, fwindowHandle, (jint)thisWin);

+    }

+

+    if(ret==JNI_TRUE && fglContext) {

+	    (*env)->SetIntField(env, obj, fglContext, (jint)gc);

+    }

+

+

+    if(ret==JNI_TRUE && fpixmapHandle!=0) {

+	    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)pix);

+    }

+

+    return ret;

+}

+

+JNIEXPORT jboolean JNICALL

+Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,

+				      jint disp,

+				      jint thisWin,

+				      jint glContext,

+				      jboolean doubleBuffer

+			      )

+{

+	jboolean ret = JNI_TRUE;

+

+        (void)glContext;

+        (void)disp;

+

+	if( !thisWin )

+	{

+            fprintf(stderr,"Swap does not got the window ...\n");

+	    return JNI_FALSE;

+	}

+

+	if( doubleBuffer==JNI_TRUE )

+	{

+		if( SwapBuffers( (HDC)thisWin ) == FALSE )

+		{

+			/* Error in Win2000 implementation :o)

+			 * printf( "Error in swap buffer!\n" );

+			 */

+	                return JNI_FALSE;

+		}

+	} else {

+		glFlush();

+	}

+	return ret;

+}

+

+static HGLRC get_GC( HDC * hDC, jboolean doubleBuffer, jboolean stereo, jint stencilBits, HGLRC shareWith, jboolean offScreenRenderer,

+					 int width, int height, HBITMAP *pix)

+

+{

+	const char * text=0;

+	HDC hDCOrig = 0;

+

+

+    if( *hDC == 0 )

+	printf( "get_GC: Error, HDC is zero\n");

+

+	// Select the pixel format

+	if(offScreenRenderer)

+	{

+		hDCOrig = *hDC;

+		*hDC = CreateCompatibleDC(hDCOrig);

+		// setupDIB(*hDC, pix, width, height);

+		setupDIB(hDCOrig, *hDC, pix, width, height);

+		/* SetDCPixelFormat(hDCOffScr, doubleBuffer, stereo, stencilBits, offScreenRenderer); */

+		/* setupPalette(hDC); USE MY PROC */

+	}

+

+	SetDCPixelFormat(*hDC, doubleBuffer, stereo, stencilBits, offScreenRenderer);

+

+	// Create palette if needed

+	hPalette = GetOpenGLPalette(*hDC);

+

+    tempRC = wglCreateContext( *hDC );

+

+	if(verbose==JNI_TRUE)

+	{

+		fprintf(stderr,"\n\nPIXELFORMAT OF GL-Context SETTINGS:\n");

+		text=GetTextualPixelFormatByHDC(*hDC);

+		fprintf(stderr,text);

+	}

+

+    /* check if the context could be created */

+    if( tempRC == NULL ) {

+        fprintf(stderr, "getGC context could NOT be created \n");

+        return( 0 );

+    }

+

+    /* associated the context with the X window */

+    if( wglMakeCurrent( *hDC, tempRC ) == FALSE) {

+		fprintf(stderr,"wglMakeCurrent(%d,%d) failed on new context!!!\n",(int)*hDC,(int)tempRC);

+		fprintf(stderr,"Error code = %d\n",(int)GetLastError());

+		wglMakeCurrent(NULL, NULL);

+		wglDeleteContext( tempRC );

+        return( 0 );

+    }

+

+	if(shareWith!=NULL && wglShareLists(shareWith, tempRC)==FALSE)

+	{

+		fprintf(stderr,"\nERROR: Could not share lists between the new and the given GLContext (Win32Native)!\n");

+		fprintf(stderr,"Error code = %d\n",(int)GetLastError());

+		wglMakeCurrent(NULL, NULL);

+		wglDeleteContext( tempRC );

+        return( 0 );

+	}

+

+    if(JNI_TRUE==verbose)

+			printf( "HGLRC (glContext) created: %d\n", tempRC );

+

+    return tempRC;

+}

+

+// Select the pixel format for a given device context

+static void SetDCPixelFormat(HDC hDC, jboolean doubleBuffer, jboolean stereo, jint stencilBits, jboolean offScreenRenderer)

+{

+    int nPixelFormat=0;

+	const char * text=0;

+

+    static PIXELFORMATDESCRIPTOR pfd = {

+			sizeof(PIXELFORMATDESCRIPTOR),  // Size of this structure

+			1,                              // Version of this structure

+			0,								// will be defined later !!!!

+			PFD_TYPE_RGBA,                  // RGBA Color mode

+			24,                             // Want 24bit color

+			0,0,0,0,0,0,                    // Not used to select mode

+			0,0,                            // Not used to select mode

+			0,0,0,0,0,                      // Not used to select mode

+			32,                             // Size of depth buffer

+			0,                              // Not used to select mode

+			0,                              // Not used to select mode

+			PFD_MAIN_PLANE,                 // Draw in main plane

+			0,                              // Not used to select mode

+			0,0,0 };                        // Not used to select mode

+

+

+	// customize dw_flags

+	DWORD dw_flags = PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED;	// Support accelerated OpenGL calls in window

+

+	if(offScreenRenderer)

+		dw_flags |= PFD_DRAW_TO_BITMAP;           // Draw to Bitmap

+	else

+		dw_flags |= PFD_DRAW_TO_WINDOW;           // Draw to Window (not to bitmap)

+

+

+	if(doubleBuffer==JNI_TRUE)

+		dw_flags |= PFD_DOUBLEBUFFER ;  // Double buffered is optional

+

+	if(stereo==JNI_TRUE)

+		dw_flags |= PFD_STEREO ;        // Stereo is optional

+

+	pfd.dwFlags = dw_flags;

+

+    pfd.cColorBits = GetDeviceCaps(hDC, BITSPIXEL);

+

+	if(stencilBits>0)

+		pfd.cStencilBits = (BYTE) stencilBits;

+

+	if(verbose==JNI_TRUE)

+	{

+		fprintf(stderr,"\n\nUSER CHOOSED PIXELFORMAT (TRYING):\n");

+		text=GetTextualPixelFormatByPFD(&pfd, 0);			

+		fprintf(stderr,text);

+	}

+

+    // Choose a pixel format that best matches that described in pfd

+    if( hDC == 0 )

+	    printf( "SetDCPixelFormat: Error, no HDC-Contex is given\n");

+    else

+	    nPixelFormat = ChoosePixelFormat(hDC, &pfd);

+

+    if( nPixelFormat == 0 )

+	    printf( "SetDCPixelFormat: Error with PixelFormat\n" );

+

+    // Set the pixel format for the device context

+    if( SetPixelFormat(hDC, nPixelFormat, &pfd) == FALSE)

+	    printf( "setpixel failed\n" );

+}

+

+

+// If necessary, creates a 3-3-2 palette for the device context listed.

+static HPALETTE GetOpenGLPalette(HDC hDC)

+{

+    HPALETTE hRetPal = NULL;	// Handle to palette to be created

+    PIXELFORMATDESCRIPTOR pfd;	// Pixel Format Descriptor

+    LOGPALETTE *pPal;			// Pointer to memory for logical palette

+    int nPixelFormat;			// Pixel format index

+    int nColors;				// Number of entries in palette

+    int i;						// Counting variable

+    BYTE RedRange,GreenRange,BlueRange;

+							    // Range for each color entry (7,7,and 3)

+

+

+    // Get the pixel format index and retrieve the pixel format description

+    nPixelFormat = GetPixelFormat(hDC);

+    DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

+

+    // Does this pixel format require a palette?  If not, do not create a

+    // palette and just return NULL

+    if(!(pfd.dwFlags & PFD_NEED_PALETTE))

+	    return NULL;

+

+    // Number of entries in palette.  8 bits yeilds 256 entries

+    nColors = 1 << pfd.cColorBits;	

+

+    // Allocate space for a logical palette structure plus all the palette entries

+    pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) + nColors*sizeof(PALETTEENTRY));

+

+    // Fill in palette header

+    pPal->palVersion = 0x300;		// Windows 3.0

+    pPal->palNumEntries = nColors; // table size

+

+    // Build mask of all 1's.  This creates a number represented by having

+    // the low order x bits set, where x = pfd.cRedBits, pfd.cGreenBits, and

+    // pfd.cBlueBits.  

+    RedRange = (1 << pfd.cRedBits) -1;

+    GreenRange = (1 << pfd.cGreenBits) - 1;

+    BlueRange = (1 << pfd.cBlueBits) -1;

+

+    // Loop through all the palette entries

+    for(i = 0; i < nColors; i++)

+	    {

+	    // Fill in the 8-bit equivalents for each component

+	    pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange;

+	    pPal->palPalEntry[i].peRed = (unsigned char)(

+		    (double) pPal->palPalEntry[i].peRed * 255.0 / RedRange);

+

+	    pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange;

+	    pPal->palPalEntry[i].peGreen = (unsigned char)(

+		    (double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange);

+

+	    pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange;

+	    pPal->palPalEntry[i].peBlue = (unsigned char)(

+		    (double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange);

+

+	    pPal->palPalEntry[i].peFlags = (unsigned char) NULL;

+	    }

+	    

+

+    // Create the palette

+    hRetPal = CreatePalette(pPal);

+

+    // Go ahead and select and realize the palette for this device context

+    SelectPalette(hDC,hRetPal,FALSE);

+    RealizePalette(hDC);

+

+    // Free the memory used for the logical palette structure

+    free(pPal);

+

+    // Return the handle to the new palette

+    return hRetPal;

+}

+

+

+JNIEXPORT void JNICALL

+Java_gl4java_GLContext_gljResizeNative( JNIEnv *env, jobject obj,

+	                                jboolean isOwnWindow,

+				        jint disp, jint thisWin,

+				        jint width, jint height)

+{

+}

+

+static jboolean testWin32Java()

+{

+    jboolean ret=JNI_TRUE;

+

+    /* NON DEPENDENCE CHECKS */

+

+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR WIN32-TYPE FITS IN �jint� */

+

+    if( sizeof(jint) < sizeof(int *) )

+    {

+        fprintf(stderr,"(int *) fits not in jint\n");

+		  ret = JNI_FALSE;

+    }

+

+    if( sizeof(jint) < sizeof(HDC) )

+    {

+        fprintf(stderr,"HDC fits not in jint\n");

+        ret = JNI_FALSE;

+    }

+

+    if( sizeof(jint) < sizeof(HGLRC) )

+    {

+        fprintf(stderr,"HGLRC fits not in jint\n");

+        ret = JNI_FALSE;

+    }

+

+    if(ret==JNI_FALSE)

+    {

+			fflush(stderr);

+    }

+

+    return ret;

+}

+

+

+static void

+PrintMessage( const char *Format, ... )

+{

+    va_list ArgList;

+    char Buffer[256];

+

+    va_start(ArgList, Format);

+    vsprintf(Buffer, Format, ArgList);

+    va_end(ArgList);

+

+	fprintf(stderr, Buffer);

+}

+

+

+static int

+PixelFormatDescriptorFromDc( HDC Dc, PIXELFORMATDESCRIPTOR *Pfd )

+{

+    int PfdIndex;

+

+    if ( 0 < (PfdIndex = GetPixelFormat( Dc )) )

+    {

+        if ( 0 < DescribePixelFormat( Dc, PfdIndex, sizeof(*Pfd), Pfd ) )

+        {

+            return(PfdIndex);

+        }

+        else

+        {

+            PrintMessage("Could not get a description of pixel format %d\n",

+                PfdIndex );

+        }

+    }

+    else

+    {

+        PrintMessage("Could not get pixel format for Dc 0x%08lX\n", Dc );

+    }

+    return( 0 );

+}

+

+

+static const char * GetTextualPixelFormatByPFD(PIXELFORMATDESCRIPTOR *ppfd, int format)

+{

+	static char buffer[2000];

+	char line[200];

+

+    sprintf(buffer,"Pixel format %d\n", format);

+    sprintf(line,"  dwFlags - 0x%x\n", ppfd->dwFlags); 

+	if (ppfd->dwFlags & PFD_DOUBLEBUFFER) { strcat(buffer, line); sprintf(line,"\tPFD_DOUBLEBUFFER\n "); }

+	if (ppfd->dwFlags & PFD_STEREO) { strcat(buffer, line); sprintf(line,"\tPFD_STEREO\n "); }

+	if (ppfd->dwFlags & PFD_DRAW_TO_WINDOW) { strcat(buffer, line); sprintf(line,"\tPFD_DRAW_TO_WINDOW\n "); }

+    if (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) { strcat(buffer, line); sprintf(line,"\tPFD_DRAW_TO_BITMAP\n "); }

+    if (ppfd->dwFlags & PFD_SUPPORT_GDI) { strcat(buffer, line); sprintf(line,"\tPFD_SUPPORT_GDI\n "); }

+    if (ppfd->dwFlags & PFD_SUPPORT_OPENGL) { strcat(buffer, line); sprintf(line,"\tPFD_SUPPORT_OPENGL\n "); }

+    if (ppfd->dwFlags & PFD_GENERIC_ACCELERATED) { strcat(buffer, line); sprintf(line,"\tPFD_GENERIC_ACCELERATED\n "); }

+    if (ppfd->dwFlags & PFD_GENERIC_FORMAT) { strcat(buffer, line); sprintf(line,"\tPFD_GENERIC_FORMAT\n "); }

+    if (ppfd->dwFlags & PFD_NEED_PALETTE) { strcat(buffer, line); sprintf(line,"\tPFD_NEED_PALETTE\n "); }

+    if (ppfd->dwFlags & PFD_NEED_SYSTEM_PALETTE) { strcat(buffer, line); sprintf(line,"\tPFD_NEED_SYSTEM_PALETTE\n "); }

+    strcat(buffer, line); sprintf(line,"\n");

+    strcat(buffer, line); sprintf(line,"  iPixelType - %d\n", ppfd->iPixelType); 

+    if (ppfd->iPixelType == PFD_TYPE_RGBA) { strcat(buffer, line); sprintf(line,"\tPGD_TYPE_RGBA\n"); }

+    if (ppfd->iPixelType == PFD_TYPE_COLORINDEX) { strcat(buffer, line); sprintf(line,"\tPGD_TYPE_COLORINDEX\n"); }

+    strcat(buffer, line); sprintf(line,"  cColorBits - %d\n", ppfd->cColorBits);

+    strcat(buffer, line); sprintf(line,"  cRedBits - %d\n", ppfd->cRedBits);

+    strcat(buffer, line); sprintf(line,"  cRedShift - %d\n", ppfd->cRedShift);

+    strcat(buffer, line); sprintf(line,"  cGreenBits - %d\n", ppfd->cGreenBits);

+    strcat(buffer, line); sprintf(line,"  cGreenShift - %d\n", ppfd->cGreenShift);

+    strcat(buffer, line); sprintf(line,"  cBlueBits - %d\n", ppfd->cBlueBits);

+    strcat(buffer, line); sprintf(line,"  cBlueShift - %d\n", ppfd->cBlueShift);

+    strcat(buffer, line); sprintf(line,"  cAlphaBits - %d\n", ppfd->cAlphaBits);

+    strcat(buffer, line); sprintf(line,"  cAlphaShift - 0x%x\n", ppfd->cAlphaShift);

+    strcat(buffer, line); sprintf(line,"  cAccumBits - %d\n", ppfd->cAccumBits);

+    strcat(buffer, line); sprintf(line,"  cAccumRedBits - %d\n", ppfd->cAccumRedBits);

+    strcat(buffer, line); sprintf(line,"  cAccumGreenBits - %d\n", ppfd->cAccumGreenBits);

+    strcat(buffer, line); sprintf(line,"  cAccumBlueBits - %d\n", ppfd->cAccumBlueBits);

+    strcat(buffer, line); sprintf(line,"  cAccumAlphaBits - %d\n", ppfd->cAccumAlphaBits);

+    strcat(buffer, line); sprintf(line,"  cDepthBits - %d\n", ppfd->cDepthBits);

+    strcat(buffer, line); sprintf(line,"  cStencilBits - %d\n", ppfd->cStencilBits);

+    strcat(buffer, line); sprintf(line,"  cAuxBuffers - %d\n", ppfd->cAuxBuffers);

+    strcat(buffer, line); sprintf(line,"  iLayerType - %d\n", ppfd->iLayerType);

+    strcat(buffer, line); sprintf(line,"  bReserved - %d\n", ppfd->bReserved);

+    strcat(buffer, line); sprintf(line,"  dwLayerMask - 0x%x\n", ppfd->dwLayerMask);

+    strcat(buffer, line); sprintf(line,"  dwVisibleMask - 0x%x\n", ppfd->dwVisibleMask);

+    strcat(buffer, line); sprintf(line,"  dwDamageMask - 0x%x\n", ppfd->dwDamageMask);

+	strcat(buffer, line); 

+	return buffer;

+}

+

+static const char * GetTextualPixelFormatByHDC(HDC hdc)

+{

+    PIXELFORMATDESCRIPTOR pfd, *ppfd;

+    int format;

+

+    ppfd   = &pfd;

+    format = PixelFormatDescriptorFromDc( hdc, ppfd );

+

+	return GetTextualPixelFormatByPFD(ppfd, format);

+}

+

+/*****************************************************************/

+

+/* Struct used to manage color ramps */

+struct colorIndexState {

+    GLfloat amb[3];	/* ambient color / bottom of ramp */

+    GLfloat diff[3];	/* diffuse color / middle of ramp */

+    GLfloat spec[3];	/* specular color / top of ramp */

+    GLfloat ratio;	/* ratio of diffuse to specular in ramp */

+    GLint indexes[3];	/* where ramp was placed in palette */

+};

+#define NUM_COLORS (sizeof(colors) / sizeof(colors[0]))

+struct colorIndexState colors[] = {

+    {

+        { 0.0F, 0.0F, 0.0F },

+        { 0.1F, 0.6F, 0.3F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+    {

+        { 0.0F, 0.0F, 0.0F },

+        { 0.0F, 0.2F, 0.5F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+    {

+        { 0.0F, 0.05F, 0.05F },

+        { 0.6F, 0.0F, 0.8F },

+        { 1.0F, 1.0F, 1.0F },

+        0.75F, { 0, 0, 0 },

+    },

+};

+

+

+static void

+setupDIB(HDC hDCOrig, HDC hDC, HBITMAP * hBitmap, int width, int height)

+{

+    BITMAPINFO *bmInfo;

+    BITMAPINFOHEADER *bmHeader;

+    UINT usage;

+    VOID *base;

+    int bmiSize;

+    int bitsPerPixel;

+	HBITMAP hOldBitmap=0;

+

+    bmiSize = sizeof(*bmInfo);

+    bitsPerPixel = GetDeviceCaps(hDC, BITSPIXEL);

+

+    switch (bitsPerPixel) {

+    case 8:

+	// bmiColors is 256 WORD palette indices 

+	bmiSize += (256 * sizeof(WORD)) - sizeof(RGBQUAD);

+	break;

+    case 16:

+	// bmiColors is 3 WORD component masks 

+	bmiSize += (3 * sizeof(DWORD)) - sizeof(RGBQUAD);

+	break;

+    case 24:

+    case 32:

+    default:

+	// bmiColors not used 

+	break;

+    }

+

+    bmInfo = (BITMAPINFO *) calloc(1, bmiSize);

+    bmHeader = &bmInfo->bmiHeader;

+

+    bmHeader->biSize = sizeof(*bmHeader);

+    bmHeader->biWidth = width;

+    bmHeader->biHeight = height;

+    bmHeader->biPlanes = 1;			// must be 1 

+    bmHeader->biBitCount = bitsPerPixel;

+    bmHeader->biXPelsPerMeter = 0;

+    bmHeader->biYPelsPerMeter = 0;

+    bmHeader->biClrUsed = 0;			// all are used 

+    bmHeader->biClrImportant = 0;		// all are important 

+

+    switch (bitsPerPixel) {

+    case 8:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_PAL_COLORS;

+	// bmiColors is 256 WORD palette indices 

+	{

+	    WORD *palIndex = (WORD *) &bmInfo->bmiColors[0];

+	    int i;

+

+	    for (i=0; i<256; i++) {

+		palIndex[i] = i;

+	    }

+	}

+	break;

+    case 16:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_RGB_COLORS;

+	// bmiColors is 3 WORD component masks 

+	{

+	    DWORD *compMask = (DWORD *) &bmInfo->bmiColors[0];

+

+	    compMask[0] = 0xF800;

+	    compMask[1] = 0x07E0;

+	    compMask[2] = 0x001F;

+	}

+	break;

+    case 24:

+    case 32:

+    default:

+	bmHeader->biCompression = BI_RGB;

+	bmHeader->biSizeImage = 0;

+	usage = DIB_RGB_COLORS;

+	// bmiColors not used 

+	break;

+    }

+

+    *hBitmap = CreateDIBSection(hDC, bmInfo, usage, &base, NULL, 0);

+    if (*hBitmap == NULL) {

+	(void) MessageBox(WindowFromDC(hDC),

+		"Failed to create DIBSection.",

+		"OpenGL application error",

+		MB_ICONERROR | MB_OK);

+	exit(1);

+    }

+

+    hOldBitmap = SelectObject(hDC, *hBitmap);

+	if(hOldBitmap!=0)

+		DeleteObject(hOldBitmap);

+

+    free(bmInfo);

+}

+

+

+/*

+static void

+setupDIB(HDC hDCOrig, HDC hDC, HBITMAP * hBitmap, int width, int height)

+{

+	HBITMAP hOldBitmap=0;

+

+	*hBitmap = CreateCompatibleBitmap(  hDCOrig, width, height );

+    if (*hBitmap == NULL) {

+        fprintf(stderr,"Failed to create CreateCompatibleBitmap! \n");

+		fflush(stderr);

+		return;

+    }

+

+    hOldBitmap = SelectObject(hDC, *hBitmap);

+	if(hOldBitmap!=0)

+		DeleteObject(hOldBitmap);

+}

+*/

+

+

+static void resizeDIB(HDC hDC, HBITMAP *hOldBitmap, HBITMAP *hBitmap)

+{

+	/*

+    SelectObject(hDC, *hOldBitmap);

+    DeleteObject(*hBitmap);

+    setupDIB(hDC, hBitmap);

+	*/

+}

+

+static void setupPalette(HDC hDC)

+{

+    PIXELFORMATDESCRIPTOR pfd;

+    LOGPALETTE* pPal;

+    int pixelFormat = GetPixelFormat(hDC);

+    int paletteSize;

+

+    DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

+

+    /*

+    ** Determine if a palette is needed and if so what size.

+    */

+    if (pfd.dwFlags & PFD_NEED_PALETTE) {

+	paletteSize = 1 << pfd.cColorBits;

+    } else if (pfd.iPixelType == PFD_TYPE_COLORINDEX) {

+	paletteSize = 4096;

+    } else {

+	return;

+    }

+

+    pPal = (LOGPALETTE*)

+	malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));

+    pPal->palVersion = 0x300;

+    pPal->palNumEntries = paletteSize;

+

+    if (pfd.iPixelType == PFD_TYPE_RGBA) {

+	/*

+	** Fill the logical paletee with RGB color ramps

+	*/

+	int redMask = (1 << pfd.cRedBits) - 1;

+	int greenMask = (1 << pfd.cGreenBits) - 1;

+	int blueMask = (1 << pfd.cBlueBits) - 1;

+	int i;

+

+	for (i=0; i<paletteSize; ++i) {

+	    pPal->palPalEntry[i].peRed =

+		    (((i >> pfd.cRedShift) & redMask) * 255) / redMask;

+	    pPal->palPalEntry[i].peGreen =

+		    (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;

+	    pPal->palPalEntry[i].peBlue =

+		    (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;

+	    pPal->palPalEntry[i].peFlags = 0;

+	}

+    } else {

+	/*

+	** Fill the logical palette with color ramps.

+	**

+	** Set up the logical palette so that it can be realized

+	** into the system palette as an identity palette.

+	**

+	** 1) The default static entries should be present and at the right

+	**    location.  The easiest way to do this is to grab them from

+	**    the current system palette.

+	**

+	** 2) All non-static entries should be initialized to unique values.

+	**    The easiest way to do this is to ensure that all of the non-static

+	**    entries have the PC_NOCOLLAPSE flag bit set.

+	*/

+	int numRamps = NUM_COLORS;

+	int rampSize = (paletteSize - 20) / numRamps;

+	int extra = (paletteSize - 20) - (numRamps * rampSize);

+	int i, r;

+

+	/*

+	** Initialize static entries by copying them from the

+	** current system palette.

+	*/

+	GetSystemPaletteEntries(hDC, 0, paletteSize, &pPal->palPalEntry[0]);

+

+	/*

+	** Fill in non-static entries with desired colors.

+	*/

+	for (r=0; r<numRamps; ++r) {

+	    int rampBase = r * rampSize + 10;

+	    PALETTEENTRY *pe = &pPal->palPalEntry[rampBase];

+	    int diffSize = (int) (rampSize * colors[r].ratio);

+	    int specSize = rampSize - diffSize;

+

+	    for (i=0; i<rampSize; ++i) {

+		GLfloat *c0, *c1;

+		GLint a;

+

+		if (i < diffSize) {

+		    c0 = colors[r].amb;

+		    c1 = colors[r].diff;

+		    a = (i * 255) / (diffSize - 1);

+		} else {

+		    c0 = colors[r].diff;

+		    c1 = colors[r].spec;

+		    a = ((i - diffSize) * 255) / (specSize - 1);

+		}

+

+		pe[i].peRed = (BYTE) (a * (c1[0] - c0[0]) + 255 * c0[0]);

+		pe[i].peGreen = (BYTE) (a * (c1[1] - c0[1]) + 255 * c0[1]);

+		pe[i].peBlue = (BYTE) (a * (c1[2] - c0[2]) + 255 * c0[2]);

+		pe[i].peFlags = PC_NOCOLLAPSE;

+	    }

+

+	    colors[r].indexes[0] = rampBase;

+	    colors[r].indexes[1] = rampBase + (diffSize-1);

+	    colors[r].indexes[2] = rampBase + (rampSize-1);

+	}

+

+	/*

+	** Initialize any remaining non-static entries.

+	*/

+	for (i=0; i<extra; ++i) {

+	    int index = numRamps*rampSize+10+i;

+	    PALETTEENTRY *pe = &pPal->palPalEntry[index];

+

+	    pe->peRed = (BYTE) 0;

+	    pe->peGreen = (BYTE) 0;

+	    pe->peBlue = (BYTE) 0;

+	    pe->peFlags = PC_NOCOLLAPSE;

+	}

+    }

+

+    hPalette = CreatePalette(pPal);

+    free(pPal);

+

+    if (hPalette) {

+	SelectPalette(hDC, hPalette, FALSE);

+	RealizePalette(hDC);

+    }

+}

+

+

diff --git a/CNativeCode/OpenGL_Win32_JDirect.c b/CNativeCode/OpenGL_Win32_JDirect.c
new file mode 100755
index 0000000..6b46874
--- /dev/null
+++ b/CNativeCode/OpenGL_Win32_JDirect.c
@@ -0,0 +1,182 @@
+/*

+ * Original Author: Leo Chan -- 1995

+ *

+ * Adam King 1997

+ *		Ported to Win32 from X

+ *

+ * Ron Cemer 1999

+ *      Ported to MS Java VM, which supports JDirect instead of JNI

+ *

+ * This file takes care of the C implementation of finding the correct

+ * Win32 window, assigning an OpenGL graphics context to it, storing that

+ * graphics context in the java class data structure.

+ *

+ * also contains the use() and swap() functions for double buffering

+ *

+ * September 12, 1997	- Adam King

+ *		- Added support for rendering directly into a Canvas ( BIG rewrite )

+ *

+ * Currently, only the windows special overlapping window procs are

+ * implemented here !

+ *

+ * The other procs are implemented with JNI !

+ */

+

+#ifdef _WIN32_

+	#include "winstuff.h"

+#endif

+

+#include "GL/gl.h"

+

+#include <stdio.h>

+

+/*--------------------------------------------------------------------------

+ * here on in is just regular apple pie C

+ */

+

+#include <GL\gl.h>

+#include <gl\glu.h>

+#include <wingdi.h>

+

+#define CLASS_NAME "GL4JavaOglRenderingWindowClass"

+#define WINDOW_NAME "GL4JavaOglRenderingWindow"

+

+#define MAX_WINDOWS 1024

+

+static int verbose = 0;

+static LONG classregistered = 0;

+

+static LRESULT CALLBACK CallWndProc(int nCode,WPARAM wParam,LPARAM lParam);

+static LRESULT CALLBACK CallWndRetProc(int nCode,WPARAM wParam,LPARAM lParam);

+

+BOOL APIENTRY DllMain

+	(HANDLE hModule, 

+     DWORD ul_reason_for_call, 

+     LPVOID lpReserved)

+	{

+    switch (ul_reason_for_call)

+        {

+        case DLL_PROCESS_ATTACH:

+                /* Initialize various things the first time

+                   that we attach this DLL to a process. */

+            if (InterlockedIncrement(&classregistered) == 1)

+		        {

+		        WNDCLASS wndclass;

+		        LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

+

+		        wndclass.style         = CS_GLOBALCLASS | CS_SAVEBITS;

+		        wndclass.lpfnWndProc   = (WNDPROC)WindowProc;

+		        wndclass.cbClsExtra    = 0;

+		        wndclass.cbWndExtra    = 0;

+		        wndclass.hInstance     = hModule;

+		        wndclass.hIcon         = LoadIcon(NULL,IDI_APPLICATION);

+		        wndclass.hCursor       = LoadCursor(NULL,IDC_ARROW);

+		        wndclass.hbrBackground = (HBRUSH)GetStockObject(LTGRAY_BRUSH);

+		        wndclass.lpszMenuName  = NULL;

+		        wndclass.lpszClassName = CLASS_NAME;

+		        RegisterClass(&wndclass);

+                }

+            else

+                InterlockedDecrement(&classregistered);

+            break;

+        case DLL_PROCESS_DETACH:

+            break;

+        case DLL_THREAD_ATTACH:

+            break;

+        case DLL_THREAD_DETACH:

+            break;

+        }

+    return TRUE;

+	}	/* DllMain() */

+

+// Select the pixel format for a given device context

+

+static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

+	{

+    return DefWindowProc(hwnd,uMsg,wParam,lParam);

+	}	/* WindowProc() */

+

+__declspec(dllexport) void OGLWindowMsgPumpJDirect(void)

+    {

+	MSG msg;

+

+	while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))

+		{

+		TranslateMessage(&msg);

+		DispatchMessage(&msg);

+		}

+    }   /* OGLWindowMsgPumpJDirect() */

+

+__declspec(dllexport) void moveOGLWindowNativeJDirect(int _hdc, int x, int y, int width, int height)

+	{

+	HWND hwnd, hwndParent;

+	HDC hdc = (HDC)_hdc;

+    RECT rect;

+    int parentx = 0, parenty = 0;

+    int insetsleft = 0, insetstop = 0;

+

+	if (hdc != NULL)

+		{

+		if ((hwnd = WindowFromDC(hdc)) != NULL)

+            {

+            if ((hwndParent = GetParent(hwnd)) != NULL)

+                {

+                GetWindowRect(hwndParent,&rect);

+                parentx = rect.left;

+                parenty = rect.top;

+                }

+            else

+                parentx = parenty = 0;

+            MoveWindow(hwnd,x-parentx,y-parenty,width,height,TRUE);

+            GetWindowRect(hwnd,&rect);

+            insetsleft = rect.left-x;

+            insetstop = rect.top-y;

+            if ( (insetsleft) || (insetstop) )

+                MoveWindow(hwnd,x-(parentx+insetsleft),y-(parenty+insetstop),width,height,TRUE);

+            }

+		}

+	}	/* moveOGLWindowNativeJDirect() */

+

+__declspec(dllexport) int createOGLWindowNativeJDirect(int hwndParent, int x, int y, int width, int height)

+	{

+	HWND hwnd;

+    HDC hdc;

+

+	if ((hwnd = CreateWindow

+		(CLASS_NAME,

+		 WINDOW_NAME,

+		 WS_CHILD | WS_VISIBLE | WS_DISABLED,

+		 x,

+		 y,

+		 width,

+		 height,

+		 (HWND)hwndParent,

+		 NULL,

+		 NULL,

+		 NULL)) == NULL)

+		{

+        fprintf(stderr,"createOGLWindowNativeJDirect(): CreateWindow failed!\n");

+		fprintf(stderr,"GetLastError() returns: %d\n",(int)GetLastError());

+		return(0);

+		}

+    hdc = GetDC(hwnd);

+    moveOGLWindowNativeJDirect((int)hdc, x, y, width, height);

+    return (int)hdc;

+	}	/* createOGLWindowNativeJDirect() */

+

+__declspec(dllexport) void destroyOGLWindowNativeJDirect(int _hdc)

+	{

+	HWND hwnd;

+	HDC hdc = (HDC)_hdc;

+

+	if (hdc != NULL)

+		{

+		if ((hwnd = WindowFromDC(hdc)) != NULL)

+			{

+			ReleaseDC(hwnd,hdc);

+            DestroyWindow(hwnd);

+			}

+		}

+	}	/* destroyOGLWindowNativeJDirect() */

+

+

diff --git a/CNativeCode/OpenGL_X11.c b/CNativeCode/OpenGL_X11.c
new file mode 100644
index 0000000..a1f3a33
--- /dev/null
+++ b/CNativeCode/OpenGL_X11.c
@@ -0,0 +1,1320 @@
+/*
+ * Leo Chan -- 1995
+ *
+ * This file takes care of the C implementation of opening up an
+ * X window, assigning an OpenGL graphics context to it, storing that
+ * graphics context in the java class data structure.
+ *
+ * also contains the use() and swap() functions for double buffering
+ *
+ * Adam King -- 1997
+ *
+ * Modified Creation window code to use the currently showing Java Frame
+ * window instead of creating a new window.
+ * ---------------
+ *
+ * Many improvements and changes are made !
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ *
+ * some X stuff is also modified/debugged to run on aix ...
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <jni.h>
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLContext.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include <GL/glx.h>
+#include <X11/Xatom.h>
+
+#include <stdlib.h>
+
+
+/*
+ * STATIC FLAGS FOR gl4java behavior ...
+ */
+static jboolean verbose = JNI_FALSE;
+
+/*
+ * prototypes for functions local to this file scope
+ */
+static int get_GC( Display *display, Window win, XVisualInfo *visual,
+                   GLXContext *gc, GLXContext gc_share);
+
+typedef struct {
+	XVisualInfo * visual;
+        GLXContext    gc;
+	int           success;  /* 1: OK, 0: ERROR */
+} VisualGC;
+
+static VisualGC findVisualGlX( Display *display, 
+			       Window rootWin,
+			       Window * pWin, 
+			       int width, int height,
+                               jboolean doubleBuffer, 
+                               jboolean stereoView,
+			       jboolean rgba,
+			       jint stencilBits,
+			       jint accumSize,
+			       jboolean * pOwnWin,
+			       GLXContext shareWith,
+			       jboolean offscreen,
+			       Pixmap *pix
+			     );
+
+static void printVisualInfo ( Display *display, XVisualInfo * vi);
+static void printAllVisualInfo ( Display *disp, Window win);
+
+static int testVisualInfo ( Display *display, XVisualInfo * vi, 
+		            int dblBuffer, int stereoView, int rgbaMode, 
+			    int stencilSize, int accumSize);
+
+static XVisualInfo * findVisualIdByFeature( XVisualInfo ** visualList, 
+                                  Display *disp, Window win,
+	                          int dblBuffer, int stereoView, int rgbaMode, 
+		                  int stencilSize, int accumSize);
+
+/* testJavaGLTypes does important implementation plattformspecific checks:
+ *
+ * o do fit the JNI <-> GL Variables-Type Mapping 
+ * o IF ERROR OR VERBOSE -> DUMP JNI,GL Type-Length
+ */
+jboolean testJavaGLTypes(jboolean verbose);
+
+/* testX11Java does important implementation plattformspecific checks:
+ *
+ * o do fit X11-Vars in jint (because GLFrame stores 'em like that)
+ */
+static jboolean testX11Java();
+
+static int x11gl_myErrorHandler(Display *pDisp, XErrorEvent *p_error)
+{
+	char err_msg[80];
+
+	XGetErrorText(pDisp, p_error->error_code, err_msg, 80);
+	fprintf(stderr, "X11 Error detected.\n %s\n", err_msg);
+	fprintf(stderr, " Protocol request: %d\n", p_error->request_code);
+	fprintf(stderr, " Resource ID : 0x%x\n", (int)p_error->resourceid);
+	fprintf(stderr, " \ntrying to continue ... \n");
+	fflush(stderr);
+	return 0;
+}
+
+static int x11gl_myIOErrorHandler(Display *pDisp)
+{
+	fprintf(stderr, "X11 I/O Error detected.\n");
+	fprintf(stderr, " \ndo not know what to do ... \n");
+	fflush(stderr);
+	return 0;
+}
+
+static Window createOwnOverlayWin(Display *display, Window rootwini, Window parentWin,
+                                  XVisualInfo *visual, int width, int height)
+{				  
+  /*
+  //------------------------------------------------------------------------//
+  // Some Systems (SGI) wont give up the window and so we have to create a  //
+  // window that fits on top of the Java Canvas.                            //
+  //------------------------------------------------------------------------//
+  */
+  Window window=0;
+  XSetWindowAttributes   attribs ;
+
+  /*
+    //----------------------------------------------------------------------//
+    // now we have the visual with the best depth so lets make a color map  //
+    // for it.  we use allocnone because this is a true colour visual and   //
+    // the color map is read only anyway. This must be done because we      //
+    // cannot call XCreateSimpleWindow.                                     // 
+    //----------------------------------------------------------------------//
+  */
+    int cmap = XCreateColormap ( display
+                               , rootwini
+                               , visual->visual
+                               , AllocNone 
+                               );
+
+  /*
+    //----------------------------------------------------------------------//
+    // Set up the window attributes.                                        //
+    //----------------------------------------------------------------------//
+  */
+    attribs.event_mask       = ExposureMask                              ;
+    attribs.border_pixel     = BlackPixel(display, DefaultScreen(display)) ;
+    attribs.colormap         = cmap                                        ;
+    attribs.bit_gravity      = SouthWestGravity ;                          ;
+    attribs.background_pixel = 0xFF00FFFF                                  ;  
+   
+  /*
+    //----------------------------------------------------------------------//
+    // Create a window.                                                     //
+    //----------------------------------------------------------------------//
+  */
+    window = XCreateWindow( display
+                          , parentWin  
+                          , 0
+                          , 0
+                          , width
+                          , height
+                          , 0
+                          , visual->depth
+                          , InputOutput
+                          , visual->visual
+                          , CWBitGravity  | CWColormap 
+                          | CWBorderPixel | CWBackPixel
+                          , &attribs);
+    
+    return window;
+}
+
+
+static void printVisualInfo ( Display *display, XVisualInfo * vi)
+{
+    int dblBuffer, stereoView, rgbaMode, stencilSize;
+    int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
+
+    fprintf(stderr, "\nvi(ID:%d(0x%X)): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d\n",
+	(int) vi->visualid,
+	(int) vi->visualid,
+	(int) vi->screen,
+	(int) vi->depth,
+	(int) vi->class,
+	(int) vi->colormap_size,
+	(int) vi->bits_per_rgb );
+
+    glXGetConfig( display, vi, GLX_DOUBLEBUFFER, &dblBuffer);
+    glXGetConfig( display, vi, GLX_STEREO, &stereoView);
+    glXGetConfig( display, vi, GLX_RGBA, &rgbaMode);
+    glXGetConfig( display, vi, GLX_STENCIL_SIZE, &stencilSize);
+    glXGetConfig( display, vi, GLX_ACCUM_RED_SIZE, &accumRedSize);
+    glXGetConfig( display, vi, GLX_ACCUM_GREEN_SIZE, &accumGreenSize);
+    glXGetConfig( display, vi, GLX_ACCUM_BLUE_SIZE, &accumBlueSize);
+    glXGetConfig( display, vi, GLX_ACCUM_ALPHA_SIZE, &accumAlphaSize);
+
+    fprintf(stderr, "\t doubleBuff: %d, ", dblBuffer);
+    fprintf(stderr, " stereo: %d, ", stereoView);
+    fprintf(stderr, " rgba: %d, ", rgbaMode);
+    fprintf(stderr, " stencilSize: %d !\n", stencilSize);
+    fprintf(stderr, "\t red accum: %d, ", accumRedSize);
+    fprintf(stderr, " green accum: %d, ", accumGreenSize);
+    fprintf(stderr, " blue accum: %d, ", accumBlueSize);
+    fprintf(stderr, " alpha accum: %d !\n", accumAlphaSize);
+
+    fflush(stderr);
+}
+
+static void printAllVisualInfo ( Display *disp, Window win)
+{
+    XVisualInfo    *	visualInfo=0;    
+    XVisualInfo    *    vi=0;
+    XVisualInfo    	viTemplate;
+    int 		i, numReturns;
+    XWindowAttributes 	xwa;
+
+    if(XGetWindowAttributes(disp, win, &xwa) == 0)
+    {
+	fprintf(stderr, "\nERROR while fetching XWindowAttributes\n");
+	fflush(stderr);
+	return;
+    }
+
+    viTemplate.screen = DefaultScreen( disp );
+    viTemplate.class = (xwa.visual)->class ;
+    viTemplate.depth = xwa.depth;
+
+    visualInfo = XGetVisualInfo( disp, VisualScreenMask,
+	&viTemplate, &numReturns ); 
+
+    if(JNI_TRUE==verbose)
+    {
+	    fprintf(stderr, "\nNum of Visuals : %d\n", numReturns );
+
+	    for(i=0; i<numReturns; i++)
+	    {
+	    	    vi = &(visualInfo[i]);
+		    printVisualInfo ( disp, vi);
+	    }
+    }
+
+    XFree(visualInfo); 	
+}
+
+static int testVisualInfo ( Display *display, XVisualInfo * vi, 
+		            int dblBuffer, int stereoView, int rgbaMode, 
+			    int stencilSize, int accumSize)
+{
+    int glxCfg;
+
+    glXGetConfig( display, vi, GLX_DOUBLEBUFFER, &glxCfg);
+    if(glxCfg<dblBuffer) return 0;
+
+    glXGetConfig( display, vi, GLX_STEREO, &glxCfg);
+    if(glxCfg<stereoView) return 0;
+
+    glXGetConfig( display, vi, GLX_RGBA, &glxCfg);
+    if(glxCfg<rgbaMode) return 0;
+
+    glXGetConfig( display, vi, GLX_STENCIL_SIZE, &glxCfg);
+    if(glxCfg<stencilSize) return 0;
+
+    glXGetConfig(display, vi, GLX_ACCUM_RED_SIZE, &glxCfg);
+    if(glxCfg<accumSize) return 0;
+
+    glXGetConfig(display, vi, GLX_ACCUM_GREEN_SIZE, &glxCfg);
+    if(glxCfg<accumSize) return 0;
+
+    glXGetConfig(display, vi, GLX_ACCUM_BLUE_SIZE, &glxCfg);
+    if(glxCfg<accumSize) return 0;
+
+    if(rgbaMode>0) {
+	    glXGetConfig(display, vi, GLX_ACCUM_ALPHA_SIZE, &glxCfg);
+	    if(glxCfg<accumSize) return 0;
+    }
+
+    return 1;
+}
+
+
+static XVisualInfo * findVisualIdByFeature( XVisualInfo ** visualList, 
+                                  Display *disp, Window win,
+	                          int dblBuffer, int stereoView, int rgbaMode, 
+		                  int stencilSize, int accumSize)
+{
+    XVisualInfo    *    vi=0;
+    XVisualInfo    	viTemplate;
+    int 		i, numReturns;
+    XWindowAttributes 	xwa;
+    int 		done=0;
+
+    if(XGetWindowAttributes(disp, win, &xwa) == 0)
+    {
+	fprintf(stderr, "\nERROR while fetching XWindowAttributes\n");
+	fflush(stderr);
+	return 0;
+    }
+
+    viTemplate.screen = DefaultScreen( disp );
+    viTemplate.class = (xwa.visual)->class ;
+    viTemplate.depth = xwa.depth;
+
+    *visualList = XGetVisualInfo( disp, VisualScreenMask,
+	                          &viTemplate, &numReturns ); 
+
+    for(i=0; done==0 && i<numReturns; i++)
+    {
+        vi = &((*visualList)[i]);
+	if ( testVisualInfo ( disp, vi, dblBuffer, stereoView, rgbaMode, 
+			      stencilSize, accumSize) )
+	{
+                if(JNI_TRUE==verbose)
+		{
+		    fprintf(stderr, "findVisualIdByFeature: Found matching Visual:\n");
+		    printVisualInfo ( disp, vi);
+		}
+		return vi;
+	}
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+	    if( numReturns==0 )
+		fprintf(stderr, "findVisualIdByFeature: No available visuals. Exiting...\n" );
+	    else if( i>=numReturns )
+		fprintf(stderr, "findVisualIdByFeature: No matching visual found ...\n" );
+	    fflush(stderr);
+    }
+     
+    XFree(*visualList);
+    *visualList=NULL;
+    return NULL;
+}
+
+/**
+ * Description for pWin:
+ *   if ownwin:
+ *      input: 	the parent window
+ *      output: the newly created window
+ *   else if ! ownwin:
+ *      i/o:    the window itself
+ */
+static VisualGC findVisualGlX( Display *display, 
+			       Window rootWin,
+			       Window * pWin, 
+			       int width, int height,
+                               jboolean doubleBuffer, 
+                               jboolean stereoView,
+			       jboolean rgba,
+			       jint stencilBits,
+			       jint accumSize,
+			       jboolean * pOwnWin,
+			       GLXContext shareWith,
+			       jboolean offscreen,
+			       Pixmap *pix
+			     )
+{
+    Window newWin = 0;
+    int visualAttribList[32];
+    int i=0;
+    int j=0;
+    int done=0;
+    VisualGC vgc = { NULL, 0, 0 };
+    jboolean tryChooseVisual = JNI_TRUE;
+    int gc_ret = 0;
+
+    /** 
+     * The Visual seeked by Function: findVisualIdByFeature !
+     */
+    XVisualInfo * visualList=NULL; /* the visual list, to be XFree-ed */
+
+    /* backup variables ... */
+    jboolean 	_rgba=rgba;
+    jint 	_stencilBits=stencilBits;
+    jint 	_accumSize=accumSize;
+    jboolean 	_stereoView=stereoView;
+    jboolean 	_doubleBuffer=doubleBuffer;
+
+    do {
+            if(JNI_TRUE==verbose)
+	    {
+	         fprintf(stderr, "GL4Java: seeking visual loop# %d\n", j);
+	    }
+
+            i=0;
+	    visualAttribList[i++] = GLX_RED_SIZE;
+	    visualAttribList[i++] = 1;
+	    visualAttribList[i++] = GLX_GREEN_SIZE;
+	    visualAttribList[i++] = 1;
+	    visualAttribList[i++] = GLX_BLUE_SIZE;
+	    visualAttribList[i++] = 1;
+	    visualAttribList[i++] = GLX_DEPTH_SIZE;
+	    visualAttribList[i++] = 1;
+	    visualAttribList[i++] = GLX_ACCUM_RED_SIZE;
+	    visualAttribList[i++] = accumSize;
+	    visualAttribList[i++] = GLX_ACCUM_GREEN_SIZE;
+	    visualAttribList[i++] = accumSize;
+	    visualAttribList[i++] = GLX_ACCUM_BLUE_SIZE;
+	    visualAttribList[i++] = accumSize;
+
+	    if(JNI_TRUE==rgba)
+	    {
+		    visualAttribList[i++] = GLX_RGBA;
+		    visualAttribList[i++] = GLX_ACCUM_ALPHA_SIZE;
+		    visualAttribList[i++] = accumSize;
+	    }
+	    if(JNI_TRUE==doubleBuffer)
+		    visualAttribList[i++] = GLX_DOUBLEBUFFER;
+	    if(JNI_TRUE==stereoView)
+		    visualAttribList[i++] = GLX_STEREO;
+	    visualAttribList[i++] = GLX_STENCIL_SIZE;
+	    visualAttribList[i++] = (int)stencilBits;
+	    visualAttribList[i] = None;
+
+            if(tryChooseVisual==JNI_TRUE && vgc.visual==NULL)
+	    {
+		    vgc.visual = glXChooseVisual( display,
+						  DefaultScreen( display ),
+						  visualAttribList );
+		    if(JNI_TRUE==verbose)
+		    {
+			if(vgc.visual!=NULL)
+			{
+			    fprintf(stderr, "glXChooseVisual: test visual(ID:%d(0x%X)):\n", 
+				(int) vgc.visual->visualid,
+				(int) vgc.visual->visualid);
+			    printVisualInfo ( display, vgc.visual);
+			} else
+			    fprintf(stderr, "glXChooseVisual: no visual\n");
+			fflush(stderr);
+		    }
+	    }
+
+	    if(vgc.visual==NULL)
+	    {
+	        vgc.visual = findVisualIdByFeature( &visualList, 
+				                      display, *pWin,
+	                                              doubleBuffer, stereoView,
+	                                              rgba, 
+						      stencilBits, 
+						      accumSize);
+	    }
+
+	    if(vgc.visual==NULL)
+	    {
+	        vgc.visual = findVisualIdByFeature( &visualList, 
+				                      display, *pWin,
+	                                              doubleBuffer, stereoView,
+	                                              rgba, 
+						      stencilBits>0, 
+						      accumSize>0);
+            }
+
+	    if( *pOwnWin == JNI_TRUE && vgc.visual!=NULL)
+	    {
+		newWin = createOwnOverlayWin(display, 
+					     rootWin, 
+					     *pWin /* the parent */,
+					     vgc.visual, width, height);
+	    }
+
+	    if( offscreen==JNI_TRUE && vgc.visual!=NULL)
+	    {
+	        if(*pix!=0)
+		{
+			XFreePixmap(display, *pix);
+		}
+		if(vgc.visual !=NULL)
+	    		*pix = XCreatePixmap( display, rootWin, width, height, 
+		                              vgc.visual->depth); 
+		if(*pix!=0)
+		{
+	           *pWin = glXCreateGLXPixmap( display,  vgc.visual, *pix );
+		   if(*pWin==0)
+		   {
+		   	XFreePixmap(display, *pix);
+			*pix=0;
+			fprintf(stderr, "GL4Java(%d): glXCreateGLXPixmap failed\n", j);
+			fflush(stderr);
+		   }
+		} else {
+		   fprintf(stderr, "GL4Java(%d): XCreatePixmap failed\n", j);
+		   fflush(stderr);
+		   *pWin = 0;
+		}
+                if(JNI_TRUE==verbose)
+		{
+			if(*pWin!=0)
+			{
+			   fprintf(stderr, "GL4Java(%d): pixmap ok\n", j);
+			   fflush(stderr);
+			}
+		}
+	    }
+
+	    gc_ret = -100;
+
+	    if( *pOwnWin == JNI_TRUE && newWin!=0 &&
+	        (gc_ret=get_GC( display, newWin,
+			        vgc.visual, &(vgc.gc), shareWith)) == 0
+              )
+	    {
+		    vgc.success=1;
+		    *pWin = newWin ;
+	    }
+	    else if( vgc.visual!=NULL &&  *pOwnWin == JNI_FALSE && *pWin!=0 &&
+	             (gc_ret=get_GC( display, *pWin,
+			             vgc.visual, &(vgc.gc), shareWith)) == 0
+	           )    
+	    {
+		    vgc.success=1;
+            } else 
+	    {
+	    	    j++; /* trial counter */
+		    if(JNI_TRUE==verbose)
+		    {
+		        fprintf(stderr, "GL4Java(%d): Visual fetching failed (gc_get=%d)\n", j, gc_ret);
+			fflush(stderr);
+		    }
+
+		    if(*pix!=0)
+		    {
+		   	XFreePixmap(display, *pix);
+			*pix=0;
+		    }
+
+		    if(visualList!=NULL)
+		    {
+			XFree(visualList);
+			visualList=NULL;
+	    		vgc.visual=NULL;
+		    } else if(vgc.visual!=NULL)
+		    {
+			XFree(vgc.visual);
+	    		vgc.visual=NULL;
+		    }
+
+		    /* Fall-Back ... */
+		    if(*pOwnWin==JNI_FALSE && offscreen==JNI_FALSE) {
+			rgba=_rgba;
+			stencilBits=_stencilBits;
+			accumSize=_accumSize;
+			stereoView=_stereoView;
+			doubleBuffer=_doubleBuffer;
+			*pOwnWin=JNI_TRUE;
+		    } else if(accumSize>0 && offscreen==JNI_TRUE) {
+		        accumSize=0;
+		    } else if(doubleBuffer==JNI_FALSE && offscreen==JNI_TRUE) {
+		        doubleBuffer=JNI_TRUE;
+		    } else if(stencilBits>0) {
+		        stencilBits=0;
+		    } else if(stereoView==JNI_TRUE) {
+			stereoView=JNI_FALSE;
+		    } else if(rgba==JNI_TRUE) {
+			rgba=JNI_FALSE;
+		    } else if(doubleBuffer==JNI_TRUE) {
+			doubleBuffer=JNI_FALSE;
+		    } else if(tryChooseVisual==JNI_TRUE) {
+			rgba=_rgba;
+			stencilBits=_stencilBits;
+			accumSize=_accumSize;
+			stereoView=_stereoView;
+			doubleBuffer=_doubleBuffer;
+			*pOwnWin=JNI_FALSE;
+			tryChooseVisual=JNI_FALSE;
+		    } else done=1;
+	    }
+    } while (vgc.success==0 && done==0) ;
+
+    if(vgc.success==1 && JNI_TRUE==verbose)
+    {
+	    fprintf(stderr, "\nfindVisualGlX vi(ID:%d): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d, shared with %d\n",
+		(int)vgc.visual->visualid,
+		(int)vgc.visual->screen,
+		(int)vgc.visual->depth,
+		(int)vgc.visual->class,
+		(int)vgc.visual->colormap_size,
+		(int)vgc.visual->bits_per_rgb,
+		(int)shareWith);
+	    printVisualInfo ( display, vgc.visual);
+    }
+
+    return vgc;
+}
+
+/*
+ * OpenGL_GLFrame_openOpenGL
+ *
+ * the function name is created by JAVAH to reflect the package and class
+ * names of the JAVA object that called this native code.
+ *
+ * the parameter is a handle to the OpenGL_OpenGLFrame object -- 
+ * the data portion
+ * followed by the method table for the class.
+ */
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj )
+{
+    int screen = 0;
+
+    /* found matching visual and gc */
+    VisualGC vgc = { NULL, 0, 0 };
+
+    jboolean ret = JNI_TRUE;
+
+    jclass cls = 0;
+    jfieldID fdisplayHandle=0, fwindowHandle=0, fpixmapHandle=0;
+    jfieldID fverbose=0;
+    jfieldID fglContext=0;
+    jfieldID fstereoView=0, frgba=0, fstencilBits=0, 
+             faccumSize=0, fownwind=0;
+    jfieldID fdoubleBuffer=0, foffScreenRenderer;
+
+    jfieldID fcreatewinw = 0, fcreatewinh = 0;
+    jfieldID fshareWith = 0;
+    jboolean joffScreenRenderer=JNI_FALSE;
+    jboolean jdoubleBuffer=JNI_TRUE;
+    jboolean jstereoView=JNI_FALSE;
+    jboolean jrgba=JNI_TRUE;
+    jint jstencilBits=0;
+    jint jaccumSize=0;
+    jboolean jownwind = JNI_FALSE ;
+    jint jcreatewinw = 0, jcreatewinh = 0;
+    jint jshareWith = 0;
+
+    /* these variables will be mapped in the java-object ! */
+    Window thisWin=0;
+    Display * display = 0;
+    Window rootwini  = 0;
+    Pixmap pix;
+
+    int iValue, iValue1, iValue2, iValue3;
+
+    cls = (*env)->GetObjectClass(env, obj);
+    if(cls==0) 
+    {
+        fprintf(stderr,"GL4Java ERROR: clazz not accessible\n");
+	fflush(stderr);
+	ret=JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE) {
+	    fverbose =(*env)->GetStaticFieldID(env, cls, "gljNativeDebug", "Z");
+	    if (fverbose == 0) 
+	    {
+                fprintf(stderr,"GL4Java: fverbose==0\n");
+                fflush(stderr);
+		ret=JNI_FALSE;
+	    } else {
+		verbose = (*env)->GetStaticBooleanField(env, cls, fverbose);
+	    }
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+	fprintf(stderr, "GL4Java: sizes:\n jint=%d\n (Display *)=%d\n GLXContext=%d\n",
+	  sizeof(jint), sizeof(Display *), sizeof(GLXContext) );
+	fflush(stderr);
+    }
+
+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR X11-TYPE FITS IN �jint� */
+    ret = testX11Java();
+    ret = testJavaGLTypes(verbose);
+
+    if(ret==JNI_TRUE) {
+	    foffScreenRenderer = 
+	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
+            if (foffScreenRenderer == 0) ret= JNI_FALSE;
+	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");
+	    if (fdoubleBuffer == 0) ret= JNI_FALSE;
+	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");
+	    if (fstereoView == 0) ret= JNI_FALSE;
+	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
+    }
+
+    if(ret==JNI_TRUE) {
+	    frgba = (*env)->GetFieldID(env, cls, "rgba", "Z");
+	    if (frgba == 0) ret= JNI_FALSE;
+	    else jrgba =(*env)->GetBooleanField(env, obj, frgba);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");
+	    if (fstencilBits == 0) ret= JNI_FALSE;
+	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
+    }
+
+    if(ret==JNI_TRUE) {
+	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");
+	    if (faccumSize == 0) ret= JNI_FALSE;
+	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fcreatewinw = (*env)->GetFieldID(env, cls, "createwinw", "I");
+	    if (fcreatewinw == 0) ret= JNI_FALSE;
+	    else jcreatewinw =(*env)->GetIntField(env, obj, fcreatewinw);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fcreatewinh = (*env)->GetFieldID(env, cls, "createwinh", "I");
+	    if (fcreatewinh == 0) ret= JNI_FALSE;
+	    else jcreatewinh =(*env)->GetIntField(env, obj, fcreatewinh);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fownwind = (*env)->GetFieldID(env, cls, "createOwnWindow", "Z");
+	    if (fownwind == 0) ret= JNI_FALSE;
+	    else jownwind =(*env)->GetBooleanField(env, obj, fownwind);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fshareWith = (*env)->GetFieldID(env, cls, "sharedGLContextNative", "I");
+	    if (fshareWith == 0) ret= JNI_FALSE;
+	    else jshareWith =(*env)->GetIntField(env, obj, fshareWith);
+    }
+
+
+    if(ret==JNI_TRUE) {
+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "I");
+	    if (fwindowHandle == 0) ret= JNI_FALSE;
+	    else thisWin =(Window) (*env)->GetIntField(env, obj, fwindowHandle);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "I");
+	    if (fpixmapHandle == 0) ret= JNI_FALSE;
+    }
+
+    if(joffScreenRenderer==JNI_TRUE)
+    {
+	    jownwind = JNI_FALSE;
+	    thisWin=0;
+    }
+
+    if(thisWin==0 && joffScreenRenderer==JNI_FALSE)
+    {
+	  fprintf(stderr,"\nGL4Java ERROR: given native window == NULL !\n");
+	  fflush(stderr);
+	  ret=JNI_FALSE;
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+	fprintf(stderr,"\nGL4Java:  (JAVA FOUND WINDOW HANDLE %d == 0x%x)\n", 
+	    (int)thisWin, (int)thisWin);
+	if(joffScreenRenderer==JNI_TRUE)
+	{
+	  fprintf(stderr,"\nGL4Java:  (USING OFFSCREEN GLPIXMAP BUFFER,\n\t forced: !ownWindow, window=NULL)\n");
+	}
+	fflush(stderr);
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+	fprintf(stderr,"\nGL4Java:  (try to use visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
+	    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba, (int)jstencilBits, (int)jaccumSize,
+	    (int)jownwind );
+	fflush(stderr);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fdisplayHandle = (*env)->GetFieldID(env, cls, "displayHandle", "I");
+	    if (fdisplayHandle == 0) ret= JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE) {
+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "I");
+	    if (fglContext == 0) ret= JNI_FALSE;
+    }
+
+	/*
+	    if(ret==JNI_TRUE)
+		XSetErrorHandler(x11gl_myErrorHandler);
+
+	    if(ret==JNI_TRUE)
+		XSetIOErrorHandler(x11gl_myIOErrorHandler);
+	*/
+
+    if(ret==JNI_TRUE)
+	    display = XOpenDisplay( NULL );
+
+    if(ret==JNI_TRUE && display == NULL ) {
+        /* return FALSE to tell JAVA that we couldn't open.  could also use
+         * SignalError() here if we would prefer to throw an exception
+         */
+	 fprintf(stderr, "GL4Java ERROR: Can not open Display\n");
+	 fflush(stderr);
+         ret = JNI_FALSE;
+    }
+
+    /* Check to see if the Xserver supports OpenGL */
+    if(ret==JNI_TRUE) {
+      if( !glXQueryExtension(display, (int *) 0, (int *) 0) ) {
+	fprintf(stderr, "GL4Java ERROR: Can not query glx extension -> Server does not support OpenGL\n");
+	fflush(stderr);
+        ret = JNI_FALSE;
+      } else {
+	if (JNI_TRUE==verbose) {
+		fprintf(stdout, "GLX by %s Version %s\n", 
+			glXGetClientString(display, GLX_VENDOR),
+			glXGetClientString(display, GLX_VERSION));
+	}
+      }
+    }
+
+    /* initialize the x stuff */
+    if(ret==JNI_TRUE)
+    {
+	    screen = DefaultScreen( display );
+            rootwini  = RootWindow(display,screen) ;
+
+	    glXMakeCurrent(display, None, NULL);
+
+            vgc = findVisualGlX( display, rootwini, &thisWin,
+	                         (int)jcreatewinw, (int)jcreatewinh, 
+                                 jdoubleBuffer, jstereoView, jrgba, 
+				 jstencilBits, jaccumSize,
+				 &jownwind, (GLXContext) jshareWith,
+				 joffScreenRenderer, &pix);
+
+	    if(vgc.success == 0 && jrgba==JNI_TRUE)
+	    {
+	        jrgba=JNI_FALSE;
+                vgc = findVisualGlX( display, rootwini, &thisWin,
+	                             (int)jcreatewinw, (int)jcreatewinh, 
+                                     jdoubleBuffer, jstereoView, jrgba, 
+				     jstencilBits, jaccumSize,
+				     &jownwind, (GLXContext) jshareWith,
+				     joffScreenRenderer, &pix);
+	    }
+
+	    if(vgc.success == 0)
+	    {
+	         fprintf(stderr,"GL4Java ERROR: GETTING GC FAILED\n");
+	         fflush(stderr);
+
+		 if(jownwind==JNI_TRUE && thisWin!=0)
+			 XDestroyWindow( display, thisWin );
+		 if(joffScreenRenderer==JNI_TRUE && pix!=0)
+			 XFreePixmap(display, pix);
+		 XCloseDisplay( display );
+		 ret = JNI_FALSE;
+	    } else {
+	    	 if(glXGetConfig( display, vgc.visual, 
+		                  GLX_DOUBLEBUFFER, &iValue)==0)
+		 {
+	                if (JNI_TRUE==verbose) {
+				fprintf(stdout,"doubleBuffer: %d\n", iValue);
+				fflush(stdout);
+			}
+			jdoubleBuffer=iValue?JNI_TRUE:JNI_FALSE;
+		        if(ret==JNI_TRUE && fdoubleBuffer!=0) {
+			    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 
+			                            jdoubleBuffer);
+		        }
+
+		 } else {
+		 	fprintf(stderr,"GL4Java: fetching doubleBuffer state failed\n");
+		        fflush(stderr);
+		 }
+	    	 if(glXGetConfig( display, vgc.visual, 
+		                  GLX_STEREO, &iValue)==0)
+		 {
+	                if (JNI_TRUE==verbose) {
+				fprintf(stdout,"stereoView: %d\n", iValue);
+				fflush(stdout);
+			}
+			jstereoView=iValue?JNI_TRUE:JNI_FALSE;
+		        if(ret==JNI_TRUE && fstereoView!=0) {
+			    (*env)->SetBooleanField(env, obj, fstereoView, 
+			                            jstereoView);
+		        }
+
+		 } else {
+		 	fprintf(stderr,"GL4Java: fetching stereoView state failed\n");
+		        fflush(stderr);
+		 }
+	    	 if(glXGetConfig( display, vgc.visual, 
+		                  GLX_RGBA, &iValue)==0)
+		 {
+	                if (JNI_TRUE==verbose) {
+				fprintf(stdout,"rgba: %d\n", iValue);
+				fflush(stdout);
+			}
+			jrgba=iValue?JNI_TRUE:JNI_FALSE;
+		        if(ret==JNI_TRUE && frgba!=0) {
+			    (*env)->SetBooleanField(env, obj, frgba, 
+			                            jrgba);
+		        }
+
+		 } else {
+		 	fprintf(stderr,"GL4Java: fetching rgba state failed\n");
+		        fflush(stderr);
+		 }
+	    	 if(glXGetConfig( display, vgc.visual, 
+		                  GLX_STENCIL_SIZE, &iValue)==0)
+		 {
+	                if (JNI_TRUE==verbose) {
+				fprintf(stdout,"stencilBits: %d\n", iValue);
+				fflush(stdout);
+			}
+			jstencilBits=iValue;
+		        if(ret==JNI_TRUE && fstencilBits!=0) {
+	                    (*env)->SetIntField(env, obj, 
+	                                        fstencilBits, (jint)jstencilBits);
+		        }
+
+		 } else {
+		 	fprintf(stderr,"GL4Java: fetching stencilBits state failed\n");
+		        fflush(stderr);
+		 }
+	    	 if(glXGetConfig( display, vgc.visual,GLX_ACCUM_RED_SIZE, &iValue)==0 &&
+	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_GREEN_SIZE, &iValue1)==0 &&
+	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_BLUE_SIZE, &iValue2)==0 &&
+	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_ALPHA_SIZE, &iValue3)==0 )
+		 {
+	                if (JNI_TRUE==verbose) {
+				fprintf(stdout,"accumSize(red): %d\n", iValue);
+				fprintf(stdout,"accumSize(green): %d\n", iValue1);
+				fprintf(stdout,"accumSize(blue): %d\n", iValue2);
+				fprintf(stdout,"accumSize(alpha): %d\n", iValue3);
+				fflush(stdout);
+			}
+			jaccumSize=iValue+iValue1+iValue2+iValue3;
+		        if(ret==JNI_TRUE && faccumSize!=0) {
+	                    (*env)->SetIntField(env, obj, 
+	                                        faccumSize, (jint)jaccumSize);
+		        }
+
+		 } else {
+		 	fprintf(stderr,"GL4Java: fetching accumSize(red) state failed\n");
+		        fflush(stderr);
+		 }
+		 if(JNI_TRUE==verbose)
+		 {
+			fprintf(stderr,"\nGL4Java: (using visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
+			    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba,
+			    (int)jstencilBits, (int)jaccumSize, (int)jownwind);
+			fflush(stderr);
+		 }
+
+	    }
+    }
+
+    /* we are now done with the visual so we should free the storage */
+
+    if(ret==JNI_TRUE)
+    {
+	    XClearWindow( display, thisWin );
+	    XMapWindow( display, thisWin );
+	    XFlush( display ); 
+    }
+
+    if(ret==JNI_TRUE && fwindowHandle!=0) {
+	    (*env)->SetIntField(env, obj, fwindowHandle, (jint)thisWin);
+    }
+
+    if(ret==JNI_TRUE && fpixmapHandle!=0) {
+	    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)pix);
+    }
+
+    if(ret==JNI_TRUE && fdisplayHandle) {
+	    (*env)->SetIntField(env, obj, fdisplayHandle, (jint)display);
+    }
+
+    if(ret==JNI_TRUE && fglContext) {
+	    (*env)->SetIntField(env, obj, fglContext, (jint)vgc.gc);
+    }
+
+    if(ret==JNI_TRUE && fownwind) {
+	    (*env)->SetBooleanField(env, obj, fownwind, jownwind);
+    }
+
+    return ret;
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLContext_gljResizeNative( JNIEnv *env, jobject obj,
+	                                jboolean isOwnWindow,
+				        jint disp, jint thisWin,
+				        jint width, jint height)
+{
+    /* perform a X11 synchronise, because rendering could be done
+     * by a native Thread .... So we have to try avoid gl* reentrance
+     * on the same GL-Context
+     */
+    glXWaitGL();
+
+    if(isOwnWindow)
+    {
+	   XResizeWindow((Display *)disp, (Window)thisWin, width, height);
+	   /* if(JNI_TRUE==verbose)
+	   {
+		fprintf(stderr, "XResizeWindow -> %d x %d\n", 
+			(int)width, (int)height);
+		fflush(stderr);
+	   } */
+    }
+
+    return;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljMakeCurrentNative( JNIEnv *env, jobject obj,
+					     jint disp,
+					     jint thisWin,
+					     jint glContext
+                                           )
+{
+    jboolean ret = JNI_TRUE;
+    GLXContext ctx = NULL;
+
+    if(glContext==0)
+    {
+	fprintf(stderr, "GL4Java ERROR: gljUse NO actual GC was created ...\n");
+	fflush(stderr);
+	return JNI_FALSE;
+    }
+
+    ctx = glXGetCurrentContext();
+
+    if(ctx==(GLXContext)glContext)
+    	return JNI_TRUE;
+
+    if(ret==JNI_TRUE)
+    {
+	    if( !glXMakeCurrent( (Display *)disp, (Window)thisWin, 
+	                         (GLXContext)glContext ) ) 
+	    {
+		fprintf(stderr, "GL4Java: gljMakeCurrent failed with GC\n  Another thread may be use it now ...\n");
+		fflush(stderr);
+		ret = JNI_FALSE;
+	    } 
+    }
+    
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljFreeNative( JNIEnv *env, jobject obj,
+				      jint disp,
+				      jint thisWin,
+				      jint glContext
+				    )
+{
+    jboolean ret = JNI_TRUE;
+
+    (void)thisWin;
+    (void)glContext;
+
+    if(ret==JNI_TRUE)
+    {
+	    if( !glXMakeCurrent( (Display *)disp, None, NULL ) ) 
+	    {
+		fprintf(stderr, "GL4Java: gljFree failed\n");
+		fflush(stderr);
+		ret = JNI_FALSE;
+	    }  
+    }
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljIsContextCurrentNative( JNIEnv *env, jobject obj,
+				      jint glContext
+				    )
+{
+    GLXContext ctx = glXGetCurrentContext();
+
+    if(ctx==(GLXContext)glContext)
+    	return JNI_TRUE;
+
+    return JNI_FALSE;
+}
+
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljDestroyNative( JNIEnv *env, jobject obj )
+{
+    jclass cls = 0;
+    jfieldID fdisplayHandle=0, fwindowHandle=0, fglContext=0;
+    jfieldID fpixmapHandle=0;
+    jfieldID fpData=0;
+
+    Display *disp=0;
+    GLXContext gc=0;
+    Window win=0;
+    jint pData=0;
+    Pixmap pix=0;
+
+    jboolean ret = JNI_TRUE;
+
+    cls = (*env)->GetObjectClass(env, obj);
+    if(cls==0) ret=JNI_FALSE;
+
+    if(ret==JNI_TRUE) {
+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "I");
+	    if (fwindowHandle == 0) ret= JNI_FALSE;
+	    else win = (Window) (*env)->GetIntField(env, obj, fwindowHandle);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fdisplayHandle = (*env)->GetFieldID(env, cls, "displayHandle", "I");
+	    if (fdisplayHandle == 0) ret= JNI_FALSE;
+	    else disp=(Display *)(*env)->GetIntField(env, obj, fdisplayHandle);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "I");
+	    if (fglContext == 0) ret= JNI_FALSE;
+	    else gc =(GLXContext)(*env)->GetIntField(env, obj, fglContext);
+    }
+
+    if(ret==JNI_TRUE) {
+	fpData = (*env)->GetFieldID(env, cls, "pData", "I");
+	if (fpData == 0) ret= JNI_FALSE;
+	else pData =(*env)->GetIntField(env, obj, fpData);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "I");
+	    if (fpixmapHandle == 0) ret= JNI_FALSE;
+	    else pix = (Pixmap)(*env)->GetIntField(env, obj, fpixmapHandle);
+    }
+
+    glXWaitGL();
+
+    if(ret==JNI_TRUE)
+    {
+	    if ( gc == 0 )
+	    {
+	        if(JNI_TRUE==verbose)
+		{
+			fprintf(stderr, "GL4Java: gljDestroy failed, GL context is 0\n");
+			fflush(stderr);
+		}
+		ret = JNI_FALSE;
+	    }
+	    if( ret==JNI_TRUE && !glXMakeCurrent( disp, None, NULL ) ) 
+	    {
+		fprintf(stderr, "GL4Java: gljDestroy failed\n");
+		fflush(stderr);
+		ret = JNI_FALSE;
+	    }  else if(ret==JNI_TRUE) {
+		glXDestroyContext(disp, gc);
+	        if(pix!=0)
+	        {
+		    XFreePixmap(disp, (Pixmap)pix);
+	        }
+	    }
+    }
+
+    if(ret==JNI_TRUE) 
+    {
+	    gc = 0;
+	    disp=0;
+	    win = 0;
+	    pix = 0;
+	    pData=0; /* remark the class, we must reinit GL-Context ! */
+    }
+
+    if(ret==JNI_TRUE && fpixmapHandle!=0) {
+	    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)pix);
+    }
+
+    if(ret==JNI_TRUE && fwindowHandle!=0) {
+	    (*env)->SetIntField(env, obj, fwindowHandle, (jint)win);
+    }
+
+    if(ret==JNI_TRUE && fdisplayHandle) {
+	    (*env)->SetIntField(env, obj, fdisplayHandle, (jint)disp);
+    }
+
+    if(ret==JNI_TRUE && fglContext) {
+	    (*env)->SetIntField(env, obj, fglContext, (jint)gc);
+    }
+
+
+    if(ret==JNI_TRUE && fpData) {
+	    (*env)->SetIntField(env, obj, fpData, (jint)pData);
+    }
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,
+				      jint disp,
+				      jint thisWin,
+				      jint glContext,
+				      jboolean doubleBuffer
+				    )
+{
+    (void)glContext;
+
+    if( doubleBuffer == JNI_FALSE ) {
+	/* don't double buffer */
+	glXWaitGL();
+    } else {
+	glXSwapBuffers( (Display *)disp, (Window)thisWin );
+    }
+
+    return JNI_TRUE;
+}
+
+/*
+ * Name      : get_GC
+ *
+ * Parameters: win    - the X window use to the OpenGL context with
+ *             visual - The visual to create the context for
+ *             gc     - a pointer to a GLXContext structure. This is how
+ *                      the created context will be returned to the caller
+ *
+ * Returns   : a pointer to a created GLXContext is returned through the
+ *             gc argument.
+ *             int - an error code: 0 means everything was fine
+ *                                 -1 context creation failed
+ *                                 -2 context/window association failed
+ *
+ * Purpose   : create an X window Graphics context and assocaite it with
+ *             the window. It returns 0 if everything was fine, -1 if the
+ *             context could not be created, -2 if the context could not
+ *             be associated with the window
+ */
+static int get_GC( Display *display, Window win, XVisualInfo *visual,
+                   GLXContext *gc, GLXContext gc_share)
+{
+    int trial = 2;
+
+    while(trial>0)
+    {
+    	switch(trial)
+	{
+	  case 2:
+	    *gc = glXCreateContext( display, visual, gc_share, GL_TRUE );
+	    break;
+	  case 1:
+	    *gc = glXCreateContext( display, visual, gc_share, GL_FALSE );
+	    break;
+	}
+    	trial--;
+
+        /* check if the context could be created */
+        if( *gc == NULL ) {
+	    continue;
+        }
+
+        /* associated the context with the X window */
+        if( glXMakeCurrent( display, win, *gc ) == False) {
+	    glXDestroyContext( display, *gc );
+	    continue;
+        } else return 0;
+    }
+
+    return -2;
+}
+
+static jboolean testX11Java()
+{
+    jboolean ret=JNI_TRUE;
+
+    /* NON DEPENDENCE CHECKS */
+
+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR X11-TYPE FITS IN �jint� */
+
+    if( sizeof(jint) < sizeof(Display *) )
+    {
+        fprintf(stderr,"GL4Java: (Display *) fits not in jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(jint) < sizeof(GLXContext) )
+    {
+        fprintf(stderr,"GL4Java: GLXContext fits not in jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(jint) < sizeof(Window) )
+    {
+        fprintf(stderr,"GL4Java: Window fits not in jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if(ret==JNI_FALSE)
+    {
+	fflush(stderr);
+    }
+
+    return ret;
+}
+
diff --git a/CNativeCode/OpenGL_funcs.c.skel b/CNativeCode/OpenGL_funcs.c.skel
new file mode 100644
index 0000000..000af1a
--- /dev/null
+++ b/CNativeCode/OpenGL_funcs.c.skel
@@ -0,0 +1,44 @@
+/*
+ * Leo Chan -- 1995
+ * [email protected]
+ *
+ * This mammoth C file takes care of all the native implementation for the
+ * bulk of OpenGL commands
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ */
+
+/* 
+ * need to include the JAVA internal header files for macros and function
+ * prototypes required to maipulated JAVA data structures and functions
+ *
+ * StubPreamble.h includes the structure and macro definitions neede to
+ * convert JAVA data structures into C data structures.
+ *
+ */
+
+#include "OpenGL_misc.h"
+
+/*
+ * the next thing to include are special headers that were created by
+ * JAVAH.  They include the C structure definitions for the JAVA classes
+ */
+#include "gl4java_GLFuncJauJNI.h"
+
+/*--------------------------------------------------------------------------
+ * here on in is just regular apple pie C
+ */
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
diff --git a/CNativeCode/OpenGL_mac.c b/CNativeCode/OpenGL_mac.c
new file mode 100644
index 0000000..0ca8663
--- /dev/null
+++ b/CNativeCode/OpenGL_mac.c
@@ -0,0 +1,2027 @@
+#include "agl.h"
+#include "aglRenderers.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+/*
+ * Leo Chan -- 1995
+ *
+ * This file takes care of the C implementation of opening up an
+ * X window, assigning an OpenGL graphics context to it, storing that
+ * graphics context in the java class data structure.
+ *
+ * also contains the use() and swap() functions for double buffering
+ *
+ * Adam King -- 1997
+ *
+ * Modified Creation window code to use the currently showing Java Frame
+ * window instead of creating a new window.
+ * ---------------
+ *
+ * Sven Goethel
+ *
+ * September 1997
+ *
+ * some X stuff is also modified/debugged to run on aix ...
+ * ---------------
+ *
+ * gerard ziemski
+ *
+ * April 1999
+ *
+ * OpenGL port for Mac
+ *
+ *
+ * July 1999
+ *
+ * removed unused code
+ *
+ *
+ * August 1999
+ *
+ * added Java_gl4java_GLContext_createChildWindow
+ *
+ *
+ * September 1999
+ *
+ * removed Java_gl4java_GLContext_createChildWindow
+ * updated to 2.1.0.0
+ *
+ *
+ * November 1999
+ *
+ * (2.1.2.0)
+ * simplified (?) get_GC
+ * rewrote gljFreeNative, gljSwapNative, gljDestroyNative
+ * wrote gljResizeNative
+ * replaced printMessage and printError with println
+ *
+ * (2.1.2.1)
+ * using the main graphics device when choosing renderer
+ * added more queries to renderer which will be printed out if in verbal mode
+ * if possible choosing hardware accelerated renderer
+ *
+ *
+ * (2.1.2.2)
+ * January 2000
+ *
+ * rewrote get_GC to choose the best renderer available
+ * 	will now work on iMac
+ * 	given enough memory to an application (3500KB) a hardware accelerated renderer will be chosen
+ *
+ * why does a call to "ReleaseStringUTFChars" in "println" crashes ?!
+ *
+ *
+ * (2.3.0.0)
+ * March 2000
+ *
+ * fixed a bug in get_GC
+ *	aglQueryRendererInfo returns the head info, i use aglNextRendererInfo to properly traverse
+ *	the rest of renderers info
+ *
+ * all this betas, when are we going to get a final version of ATI and VooDoo OpenGL drivers ?
+ * and lets not forget about the MRJ itself
+ *
+ *
+ * (2.3.1.0)
+ * March 2000
+ *
+ * fixed (a workaround) the "obscured window" bug, see "gljMakeCurrentNative"
+ * implemented Java console for fprintf's, see mac_console.c
+ *
+ *
+ * (2.4.1.0)
+ * Sept 2000, Sven Goethel (jausoft)
+ *
+ * Added 2.4.1.0 GL/AGL Features
+ */
+
+
+// use
+//
+// tvb GetSharedLibrary ';dm r3'
+//
+// in MacsBug to see what libraries are loaded
+
+
+//
+// Includes
+//
+
+#include <jni.h>
+
+#include <agl.h>
+#include <gl.h>
+#include <glu.h>
+
+#include <QuickDraw.h>
+#include <MacWindows.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+//
+// Private Includes
+//
+
+#include "gl4java_GLContext.h"
+#include "mac_console.h"
+
+// from here on, it's just a regular apple pie C
+
+// implemented in OpenGL_misc.c
+extern jboolean testJavaGLTypes(jboolean verbose);
+
+
+// for debugging
+//#define _DEBUG_OPENGL_MAC_
+//#define _DEBUG_DETAIL_OPENGL_MAC_
+
+
+//
+// Definitions
+//
+
+#define PIXEL_FROMAT_LIST_SIZE	40
+
+typedef struct
+{
+	GLboolean	valid;
+	
+	GLint		id;
+	
+	GLboolean	accelerated;
+	
+	GLint		depthModes;
+	
+	GLint		colorModes;
+	
+	GLint		stencilModes;
+	GLint		stencilSize;
+	GLint		accumModes;
+	GLint		accumSize;
+	
+	GLboolean	singleBuffer;
+	GLboolean	doubleBuffer;
+	GLboolean	mono;
+	GLboolean	stereo;
+}
+RendererRect, *RendererRectPtr, **RendererRectHnd;
+
+typedef struct
+{
+	UInt32			count;
+	
+	RendererRectPtr	info;
+	
+	GLint			attributeList[PIXEL_FROMAT_LIST_SIZE];
+}
+RenderersInfoRect, *RenderersInfoRectPtr, **RenderersInfoRectHnd;
+
+/*
+ * STATIC FLAGS FOR gl4java behavior ...
+ */
+static jboolean verbose = JNI_FALSE;
+
+
+//
+// Private Function Prottypes
+//
+
+static jboolean		testMacJava(JNIEnv *env);
+
+static AGLContext	get_GC(JNIEnv *env, AGLDrawable glDrawable, 
+			       jboolean verbose, jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize, AGLContext sharedGLC,
+			       jboolean isOffScr, GWorldPtr *g_world, int width, int height);
+
+static GLint		setDefaultPixelFormat(JNIEnv *env, 
+                               GLint (*pixelFormatList)[PIXEL_FROMAT_LIST_SIZE],
+			       jboolean verbose, jboolean doubleBuffer, 
+			       jboolean stereo, jboolean isRGBA,
+			       int stencilBits, int accumSize,
+			       jboolean isOffScr, int pixelsize);
+						
+static void	        printPixelFormat(JNIEnv *env, 
+                               GLint pixelFormatList[PIXEL_FROMAT_LIST_SIZE]);
+static GLboolean	isColorARGB(JNIEnv *env, GLint colorModes);
+static GLboolean	isColorRGB(JNIEnv *env, GLint colorModes);
+static GLint		chooseBestColor(JNIEnv *env, GLint colorModes);
+static GLint		chooseBestDepth(JNIEnv *env, GLint depthModes);
+static GLint		mapAGLDepth2DecDepth(JNIEnv *env, GLint depthModes);
+static void		getRenderersInfo(JNIEnv *env, RenderersInfoRectPtr info);
+static void 		printRendererInfo(JNIEnv *env, AGLRendererInfo info);
+static void		printRawRendererInfo(JNIEnv *env, RendererRect info);
+static void		chooseBestRenderer(JNIEnv *env, 
+                                           RenderersInfoRectPtr info, 
+			       jboolean verbose, jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize,
+			       jboolean isOffScr, jboolean forceSWRenderer);
+
+static void		printAllRenderer(JNIEnv *env);
+
+static void printPixelFormatInfo(JNIEnv *env, AGLPixelFormat info);
+
+static void checkPixelFormatInfo(JNIEnv *env, AGLPixelFormat info,
+			       jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize);
+
+//
+// Java_gl4java_GLContext_openOpenGLNative
+//
+JNIEXPORT jboolean JNICALL 
+Java_gl4java_GLContext_openOpenGLNative(JNIEnv *env, jobject obj)
+{
+    jclass		javaClass		= 0;
+
+    jfieldID	        fwindowHandle	        = 0,
+    			fpData			= 0;
+
+    jint		pData			= 0;
+    UInt32		*data			= nil;
+
+    AGLDrawable	        glDrawable		= nil;
+    AGLContext	        glContext		= nil;
+
+    jfieldID fverbose=0, fglContext=0;
+    jfieldID fstereoView=0, frgba=0, fstencilBits=0, faccumSize=0, fownwind=0;
+    jfieldID fdoubleBuffer=0, foffScreenRenderer, fpixmapHandle=0;
+    jfieldID fcreatewinw = 0, fcreatewinh = 0;
+    jfieldID fshareWith = 0;
+
+    jboolean joffScreenRenderer=JNI_FALSE;
+    jboolean jdoubleBuffer=JNI_TRUE;
+    jboolean jstereoView=JNI_FALSE;
+    jboolean jrgba=JNI_TRUE;
+    jint jstencilBits=0;
+    jint jaccumSize=0;
+    jboolean jownwind = JNI_FALSE, ret=JNI_TRUE;
+    jint jcreatewinw = 0, jcreatewinh = 0;
+    jint jshareWith = 0;
+
+    // offscreen stuff ...
+    GWorldPtr g_world;
+
+	InstallJavaConsole(env);
+		
+#ifdef _DEBUG_OPENGL_MAC_	
+		fprintf(stderr, "in openOpenGLNative \n");
+#endif
+	
+    javaClass = (*env)->GetObjectClass(env, obj);
+    if (javaClass == 0)
+	{
+		fprintf(stderr, "Error! openOpenGL:javaClass == 0 \n");
+		
+		return JNI_FALSE;
+    }
+
+    fverbose = (*env)->GetStaticFieldID(env, javaClass, "gljNativeDebug", "Z");
+    if (fverbose == 0)
+    {
+		fprintf(stderr, "Error! openOpenGL:fverbose == 0 \n");
+		
+		return JNI_FALSE;
+    }
+    else
+    {
+		verbose = (*env)->GetStaticBooleanField(env, javaClass, fverbose);
+    }
+
+#ifdef _DEBUG_OPENGL_MAC_	
+		verbose = JNI_TRUE;
+#endif
+
+    if (verbose == JNI_TRUE)
+    {
+		fprintf(stderr, "sizes: jint=%d AGLDrawable=%d AGLContext= %d \n", sizeof(jint), sizeof(AGLDrawable), sizeof(AGLContext));
+    }
+	
+    if ((testMacJava(env) && testJavaGLTypes(verbose)) != JNI_TRUE)
+    {
+		fprintf(stderr, "Error! openOpenGL: JNI & OpenGL-Native data does not fit !\n");
+		return JNI_FALSE;
+    }
+    
+    fglContext=(*env)->GetFieldID(env, javaClass, "glContext", "I");
+    if (fglContext == 0)
+    {
+		fprintf(stderr, "Error! openOpenGL:fglContext == 0 \n");
+		return JNI_FALSE;
+    } else {
+    	if (verbose == JNI_TRUE)
+    		fprintf(stderr, "openOpenGL: fglContext ok \n");
+    }
+
+    if(ret==JNI_TRUE) {                                                               
+    		foffScreenRenderer = (*env)->GetFieldID(env, javaClass, "offScreenRenderer", "Z");
+      if (foffScreenRenderer == 0) ret= JNI_FALSE;
+            else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
+    }                                                                     
+    
+    if(ret==JNI_TRUE) {
+            fdoubleBuffer = (*env)->GetFieldID(env, javaClass, "doubleBuffer", "Z");
+            if (fdoubleBuffer == 0) ret= JNI_FALSE;
+            else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
+    }
+
+    if(ret==JNI_TRUE) {                                                               
+    	    fstereoView = (*env)->GetFieldID(env, javaClass, "stereoView", "Z");
+            if (fstereoView == 0) ret= JNI_FALSE;
+            else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
+    }
+
+    if(ret==JNI_TRUE) {
+            frgba = (*env)->GetFieldID(env, javaClass, "rgba", "Z");
+            if (frgba == 0) ret= JNI_FALSE;
+            else jrgba =(*env)->GetBooleanField(env, obj, frgba);
+    }
+
+    if(ret==JNI_TRUE) {
+            fstencilBits = (*env)->GetFieldID(env, javaClass, "stencilBits", "I");
+            if (fstencilBits == 0) ret= JNI_FALSE;
+            else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
+    }
+
+    if(ret==JNI_TRUE) {
+            faccumSize = (*env)->GetFieldID(env, javaClass, "accumSize", "I");
+            if (faccumSize == 0) ret= JNI_FALSE;
+            else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
+    }
+
+    if(ret==JNI_TRUE) {
+            fcreatewinw = (*env)->GetFieldID(env, javaClass, "createwinw", "I");
+            if (fcreatewinw == 0) ret= JNI_FALSE;
+            else jcreatewinw =(*env)->GetIntField(env, obj, fcreatewinw);
+    }
+
+    if(ret==JNI_TRUE) {
+            fcreatewinh = (*env)->GetFieldID(env, javaClass, "createwinh", "I");
+            if (fcreatewinh == 0) ret= JNI_FALSE;
+            else jcreatewinh =(*env)->GetIntField(env, obj, fcreatewinh);
+    }
+
+    if(ret==JNI_TRUE) {
+            fownwind = (*env)->GetFieldID(env, javaClass, "createOwnWindow", "Z");
+            if (fownwind == 0) ret= JNI_FALSE;
+            else jownwind =(*env)->GetBooleanField(env, obj, fownwind);
+    }
+
+    if(ret==JNI_TRUE) {
+            fshareWith = (*env)->GetFieldID(env, javaClass, "sharedGLContextNative", "I");
+            if (fshareWith == 0) ret= JNI_FALSE;
+            else jshareWith =(*env)->GetIntField(env, obj, fshareWith);
+    }
+
+    if(ret==JNI_TRUE) {
+            fwindowHandle = (*env)->GetFieldID(env, javaClass, "windowHandle", "I");
+            if(fwindowHandle == 0) ret= JNI_FALSE;
+    }
+   
+
+    if(ret==JNI_TRUE) {
+	    fpData = (*env)->GetFieldID(env, javaClass, "pData", "I");
+	    if (fpData == 0)
+	    {
+			fprintf(stderr, "Error! openOpenGL:fpData == 0 \n");
+			return JNI_FALSE;
+	    }
+	    else
+	    {
+		    pData =(*env)->GetIntField(env, obj, fpData);
+		    if (verbose == JNI_TRUE)
+		    	fprintf(stderr, "openOpenGL: received pData  %d \n", (UInt32)pData);
+	    }
+    }
+
+    if(ret==JNI_TRUE) {
+            fpixmapHandle = (*env)->GetFieldID(env, javaClass, "pixmapHandle", "I");
+            if (fpixmapHandle == 0) ret= JNI_FALSE;
+    }
+
+    if(joffScreenRenderer==JNI_TRUE)
+    {
+            jownwind = JNI_FALSE;
+            pData=0;
+    }
+
+    if(pData==0 && joffScreenRenderer==JNI_FALSE)
+    {
+          fprintf(stderr,"\nGL4Java ERROR: given native window == NULL !\n");
+          fflush(stderr);
+          return JNI_FALSE;
+    }
+
+    if(joffScreenRenderer==JNI_FALSE)
+    {
+      data = (UInt32 *)pData;
+      if (data == 0)
+      {
+	fprintf(stderr, "Error! openOpenGL:data == 0 \n");
+	return JNI_FALSE;
+      } else {
+    	glDrawable = (AGLDrawable)pData;
+    	if (glDrawable == nil)
+    	{
+		fprintf(stderr, "Error! openOpenGL:glDrawable == nil \n");
+		return JNI_FALSE;
+	} else if (verbose == JNI_TRUE) {
+	    	fprintf(stderr, "openOpenGL: glDrawable ok \n");
+        }
+      }
+    }
+    	
+    glContext = get_GC(env, glDrawable, 
+                       verbose, &jdoubleBuffer, 
+                       &jstereoView, &jrgba,
+		       &jstencilBits, &jaccumSize, (AGLContext)jshareWith,
+		       joffScreenRenderer, &g_world, jcreatewinw, jcreatewinh);
+
+    if (glContext == nil)
+    {
+		fprintf(stderr, "Error! openOpenGL:glContext == nil \n");
+		
+		return JNI_FALSE;
+	}
+	
+    (*env)->SetIntField(env, obj, fdoubleBuffer, jdoubleBuffer);
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "openOpenGL: set jdoubleBuffer  %d \n", (UInt32)jdoubleBuffer);
+	}
+	
+    (*env)->SetIntField(env, obj, fstereoView, jstereoView);
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "openOpenGL: set jstereoView  %d \n", (UInt32)jstereoView);
+	}
+	
+    (*env)->SetBooleanField(env, obj, frgba, jrgba);
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "openOpenGL: set jrgba  %d \n", (UInt32)jrgba);
+	}
+	
+    (*env)->SetIntField(env, obj, fstencilBits, jstencilBits);
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "openOpenGL: set jstencilBits  %d \n", (UInt32)jstencilBits);
+	}
+	
+    (*env)->SetIntField(env, obj, faccumSize, jaccumSize);
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "openOpenGL: set jaccumSize  %d \n", (UInt32)jaccumSize);
+	}
+	
+    (*env)->SetIntField(env, obj, fwindowHandle, (jint)glDrawable);
+	
+    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)g_world);
+	
+    (*env)->SetIntField(env, obj, fglContext, (jint)glContext);
+				
+    return JNI_TRUE;
+}
+
+//
+// Java_gl4java_GLContext_gljMakeCurrentNative
+//
+JNIEXPORT jboolean JNICALL 
+Java_gl4java_GLContext_gljMakeCurrentNative(JNIEnv *env, jobject obj, 
+					    jint disp,
+					    jint thisWin,
+					    jint glContext
+					   )
+{
+#ifdef _DEBUG_DETAIL_OPENGL_MAC_	
+	fprintf(stderr, "in gljMakeCurrentNative, disp=%d, thisWin=%d, glContext=%d\n", disp, thisWin, glContext);
+#endif
+	GrafPtr	port,
+			savedPort;	
+
+
+	InstallJavaConsole(env);
+	
+	// a workaround for the "obscured window" bug
+	if (thisWin != nil)
+	{
+		port = (GrafPtr)thisWin;
+		GetPort(&savedPort);
+		SetPort(port);
+		ClipRect(&((*(port->visRgn))->rgnBBox));
+		SetPort(savedPort);
+	}
+	
+	/*
+	if (freeContextFirst == JNI_TRUE)
+	{
+		aglSetDrawable((AGLContext)glContext, nil);
+		aglSetCurrentContext(nil);
+	}*/
+	
+    if (aglSetDrawable((AGLContext)glContext, (AGLDrawable)thisWin) == GL_FALSE)
+    {
+		fprintf(stderr, "Warning! aglSetDrawable failed \n");
+    }
+    else
+    {
+	    if (aglSetCurrentContext((AGLContext)glContext) == GL_FALSE)
+	    {
+			fprintf(stderr, "Warning! gljMakeCurrentNative: could not set context \n");
+	    }
+	}
+		
+    return JNI_TRUE;
+}
+
+//
+// Java_gl4java_GLContext_gljFreeNative
+//
+JNIEXPORT jboolean JNICALL 
+Java_gl4java_GLContext_gljFreeNative(JNIEnv *env, jobject obj,
+				     jint disp,
+				     jint thisWin,
+				     jint glContext)
+{
+	InstallJavaConsole(env);
+	
+#ifdef _DEBUG_DETAIL_OPENGL_MAC_	
+	fprintf(stderr, "in gljFreeNative, disp=%d, thisWin=%d, glContext=%d \n", disp, thisWin, glContext);
+#endif
+	
+    if (aglSetDrawable((AGLContext)glContext, nil) == GL_FALSE)
+    {
+		fprintf(stderr, "gljFreeNative: aglSetDrawable failed \n");
+		
+		return JNI_FALSE;
+    }
+    else
+    {
+	    if (aglSetCurrentContext(nil) == GL_FALSE)
+	    {
+			fprintf(stderr, "gljFreeNative: aglSetCurrentContext failed \n");
+			
+			return JNI_FALSE;
+	    }
+	}
+		
+    return JNI_TRUE;
+}
+
+//
+// Java_gl4java_GLContext_gljDestroyNative
+//
+JNIEXPORT jboolean JNICALL 
+Java_gl4java_GLContext_gljDestroyNative(JNIEnv *env, jobject obj)
+{
+	jclass		javaClass		= 0;
+	jfieldID	fwindowHandle	= 0,
+				fpData			= 0,
+				fglContext		= 0,
+				 foffScreenRenderer=0,
+				fpixmapHandle=0;
+	AGLContext	glContext		= nil;
+	jboolean joffScreenRenderer=JNI_FALSE;
+	
+	// offscreen stuff ...
+    	GWorldPtr g_world;
+   	PixMapHandle pixMap;
+	
+	InstallJavaConsole(env);
+
+#ifdef _DEBUG_OPENGL_MAC_	
+	fprintf(stderr, "in gljDestroyNative \n");
+#endif
+	
+	javaClass = (*env)->GetObjectClass(env, obj);
+	if (javaClass == 0)
+	{
+		fprintf(stderr, "Error! gljDestroy:javaClass == 0 \n");
+		
+	    return JNI_FALSE;
+	}
+	
+	fwindowHandle = (*env)->GetFieldID(env, javaClass, "windowHandle", "I");
+	if (fwindowHandle == 0)
+	{
+		fprintf(stderr, "Error! openOpenGL:fwindowHandle == 0 \n");
+		
+		return JNI_FALSE;
+	}
+	
+    fglContext = (*env)->GetFieldID(env, javaClass, "glContext", "I");
+    if (fglContext == 0)
+    {
+		fprintf(stderr, "Error! gljDestroy:fglContext == 0 \n");
+		
+	    return JNI_FALSE;
+	}
+    else
+    {
+    	glContext = (AGLContext)(*env)->GetIntField(env, obj, fglContext);
+    	if (glContext == nil)
+    	{
+			fprintf(stderr, "Error! gljDestroy:glContext == nil \n");
+			
+		    return JNI_FALSE;
+    	}
+    }
+                                                           
+    foffScreenRenderer = (*env)->GetFieldID(env, javaClass, "offScreenRenderer", "Z");
+    if (foffScreenRenderer == 0) return JNI_FALSE;
+    joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
+                                                  
+    fpixmapHandle = (*env)->GetFieldID(env, javaClass, "pixmapHandle", "I");
+    if (fpixmapHandle == 0) return JNI_FALSE;
+    g_world = (GWorldPtr)(*env)->GetIntField(env, obj, fpixmapHandle);
+    	
+	aglSetCurrentContext(nil);
+	
+	if(joffScreenRenderer==JNI_FALSE)
+	{
+	   if ((aglSetDrawable(glContext, nil) == GL_FALSE))
+	   {
+		fprintf(stderr, "Warning! gljDestroy:aglSetDrawable failed (free) \n");
+		
+		return JNI_FALSE;
+	   }
+	   else
+	   {
+		aglDestroyContext(glContext);
+	   }
+	} else {
+		/* Destroy the window and GWorld */
+		pixMap = GetGWorldPixMap(g_world);
+		UnlockPixels(pixMap);
+		DisposeGWorld(g_world);
+	}
+    (*env)->SetIntField(env, obj, fwindowHandle, (jint)nil);
+    (*env)->SetIntField(env, obj, fglContext, (jint)nil);
+    (*env)->SetIntField(env, obj, fpData, (jint)nil);
+    (*env)->SetIntField(env, obj, fpixmapHandle, (jint)nil);
+    
+    UninstallJavaConsole();
+    
+    return JNI_TRUE;
+}
+
+//
+// Java_gl4java_GLContext_gljSwap
+//
+JNIEXPORT jboolean JNICALL 
+Java_gl4java_GLContext_gljSwapNative(JNIEnv *env, jobject obj,
+				     jint disp,
+				     jint thisWin,
+				     jint glContext,
+				     jboolean doubleBuffer)
+{
+	InstallJavaConsole(env);
+	
+#ifdef _DEBUG_DETAIL_OPENGL_MAC_	
+	fprintf(stderr, "in gljSwap, disp=%d, thisWin=%d, glContext=%d, doubleBuffer= %d \n", disp, thisWin, glContext, doubleBuffer);
+#endif
+	
+	if (glContext == nil)
+	{
+		fprintf(stderr, "Error! gljSwapNative:glContext == nil \n");
+		
+		return JNI_FALSE;
+	}
+	
+	if (doubleBuffer == JNI_TRUE)
+	{
+		aglSwapBuffers((AGLContext)glContext);
+	}
+	
+	return JNI_TRUE;
+}
+
+//
+// Java_gl4java_GLContext_gljResize
+//
+//
+JNIEXPORT void JNICALL 
+Java_gl4java_GLContext_gljResizeNative(JNIEnv *env, jobject obj,
+										jboolean isOwnWindow,
+										jint disp, jint thisWin,
+										jint width, jint height)
+{
+	jclass		javaClass		= 0;
+	jfieldID	fpData			= 0,
+				fglContext		= 0;
+	AGLContext	glContext		= nil;
+
+
+	InstallJavaConsole(env);
+	
+#ifdef _DEBUG_OPENGL_MAC_	
+	fprintf(stderr, "in gljResize, width=%d, height= %d \n", width, height);
+#endif
+	
+/*
+	javaClass = (*env)->GetObjectClass(env, obj);
+	if (javaClass == 0)
+	{
+		fprintf(stderr, "Error! gljResizeNative:javaClass == 0 \n");
+		
+	    return;
+	}
+	
+    fglContext = (*env)->GetFieldID(env, javaClass, "glContext", "I");
+    if (fglContext == 0)
+    {
+		fprintf(stderr, "Error! gljResizeNative:fglContext == 0 \n");
+		
+	    return;
+	}
+    else
+    {
+    	glContext = (AGLContext)(*env)->GetIntField(env, obj, fglContext);
+    	if (glContext == nil)
+    	{
+			fprintf(stderr, "Error! gljResizeNative:glContext == nil \n");
+			
+		    return;
+    	}
+    }
+	
+	aglUpdateContext(glContext);
+*/
+}
+
+#pragma mark -
+
+//
+// testMacJava
+//
+static jboolean testMacJava(JNIEnv *env)
+{
+    jboolean ret = JNI_TRUE;
+    
+	
+	if (sizeof(jint) < sizeof(UInt32 *))
+	{
+		fprintf(stderr, "UInt32 does NOT fit in jint \n");
+		
+		ret = JNI_FALSE;
+	}
+	
+	if (sizeof(jint) < sizeof(AGLDrawable))
+	{
+		fprintf(stderr, "AGLDrawable does NOT fit in jint \n");
+		
+		ret = JNI_FALSE;
+	}
+	
+	if (sizeof(jint) < sizeof(AGLContext))
+	{
+		fprintf(stderr, "AGLContext does NOT fit in jint \n");
+		
+		ret = JNI_FALSE;
+	}
+	
+	return ret;
+}
+
+//
+// AGLContext
+//
+static AGLContext	get_GC(JNIEnv *env, AGLDrawable glDrawable, 
+			       jboolean verbose, jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize, AGLContext sharedGLC,
+			       jboolean isOffScr, GWorldPtr *g_world, int width, int height)
+
+{
+	GDHandle			device		= GetMainDevice();
+	AGLContext			context		= nil;
+	AGLPixelFormat		pixelformat	= nil;
+	RenderersInfoRect	info;
+	GLenum				err;
+	
+    // offscreen stuff ...
+    Rect rect;
+    PixMapHandle pixMap;
+    void *baseaddr;
+    long pixelsize=0;
+    int rowbytes;
+    QDErr qdErr;
+
+	
+#ifdef _DEBUG_OPENGL_MAC_	
+	verbose = JNI_TRUE;
+    fprintf(stderr, "in get_GC, glDrawable=0x%X, verbose=%d, doubleBuffer=%d, stereo= %d \n", glDrawable, verbose, *doubleBuffer, *stereo);
+#endif
+	
+	if (glDrawable == nil && isOffScr==JNI_FALSE)
+	{
+		fprintf(stderr, "get_GC: Error, glDrawable is nil \n");
+		return nil;
+	}
+	
+	if (verbose == JNI_TRUE)
+	{
+		printAllRenderer(env);
+	}
+
+	if(isOffScr==JNI_TRUE)
+	{
+		/* Find the depth of the main screen */
+		pixelsize = (*(*GetMainDevice())->gdPMap)->pixelSize;
+
+		/* Create the offscreen gworld */
+		SetRect(&rect, 0, 0, width, height);
+		qdErr = NewGWorld(g_world, (short) pixelsize, &rect, NULL, NULL, useTempMem);
+		if(qdErr || !(*g_world)) {
+			fprintf(stderr, "get_GC: Error, NewGWorld is nil \n");
+			return nil;
+		}
+	
+		/* Lock pixmap handle and get its specifications */
+		pixMap = GetGWorldPixMap(*g_world);
+		LockPixels(pixMap);
+		baseaddr = GetPixBaseAddr(pixMap);
+		rowbytes = (**pixMap).rowBytes & 0x7FFF;
+	}
+	
+	setDefaultPixelFormat(env, &info.attributeList, 
+		verbose, *doubleBuffer, *stereo, *isRGBA, *stencilBits,
+		*accumSize, isOffScr, pixelsize);
+
+	if(isOffScr==JNI_FALSE)
+	{
+		getRenderersInfo(env, &info);
+		chooseBestRenderer(env, &info,
+			       verbose, doubleBuffer, 
+			       stereo, isRGBA,
+			       stencilBits, accumSize,
+			       isOffScr, false);
+	}
+	// create pixel format
+    if (verbose == JNI_TRUE)
+    {
+		printPixelFormat(env, info.attributeList);
+    }
+    
+    	if(isOffScr==JNI_FALSE)
+		pixelformat = aglChoosePixelFormat(&device, 1, info.attributeList);
+	else
+		pixelformat = aglChoosePixelFormat(NULL, 0, info.attributeList);
+			
+	if (pixelformat == nil)
+	{
+		fprintf(stderr, "get_GC: Error, pixelformat is nil \n");
+		
+		return nil;
+	}
+	else if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "pixelformat ok \n");
+		printPixelFormatInfo(env, pixelformat);
+	}
+	
+	DisposePtr((Ptr)info.info);
+	
+	// create AGL context
+	context = aglCreateContext(pixelformat, sharedGLC);
+	if (context == nil)
+	{
+		fprintf(stderr, "getGC context could NOT be created \n");
+		
+		return nil;
+	}
+	else if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "context ok \n");
+		
+		/*
+		parameter = 0;
+		if (aglSetInteger(context, AGL_SWAP_INTERVAL, &parameter) == GL_FALSE)
+		{
+			fprintf(stderr, "setting AGL_SWAP_INTERVAL failed \n");
+		}
+		*/
+	}
+	
+        checkPixelFormatInfo(env, pixelformat, doubleBuffer, 
+			     stereo, isRGBA, stencilBits, accumSize);
+
+ 	if(isOffScr==JNI_FALSE)
+ 	{
+	  // associate the context with the Mac drawable (window)
+	  if (aglSetDrawable(context, glDrawable) == GL_FALSE)
+	  {
+		fprintf(stderr, "aglSetDrawable NOT successfull \n");
+		
+		aglDestroyPixelFormat(pixelformat);
+		aglDestroyContext(context);
+		
+		return nil;
+	  }
+	  else if (verbose == JNI_TRUE)
+	  {
+		fprintf(stderr, "aglSetDrawable successfull \n");
+	  }
+	} else {
+	  /* Attach the off screen area to the context */
+	  if(!aglSetOffScreen(context, width, height, rowbytes, baseaddr)) return nil;
+	}
+
+	if (aglSetCurrentContext(context) == GL_FALSE)
+	{
+		fprintf(stderr, "aglSetCurrentContext NOT successfull \n");
+		
+		aglDestroyPixelFormat(pixelformat);
+		aglDestroyContext(context);
+		
+		return nil;
+	}
+	else if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "aglSetCurrentContext successfull \n");
+	}
+	
+	if (verbose == JNI_TRUE)
+	{
+		fprintf(stderr, "AGLContext created:  %d \n", (UInt32)context);
+	}
+		
+	aglDestroyPixelFormat(pixelformat);
+	
+	return context;
+}
+
+#pragma mark -
+
+//
+// setDefaultPixelFormat
+//
+static GLint setDefaultPixelFormat(JNIEnv *env, GLint (*pixelFormatList)[PIXEL_FROMAT_LIST_SIZE],
+			       jboolean verbose, jboolean doubleBuffer, 
+			       jboolean stereo, jboolean isRGBA,
+			       int stencilBits, int accumSize,
+			       jboolean isOffScr, int pixelsize)
+{
+	int i=0;
+	int help;
+	
+	(*pixelFormatList)[i++] = AGL_RENDERER_ID;
+	(*pixelFormatList)[i++] = AGL_RENDERER_GENERIC_ID;
+	//(*pixelFormatList)[i++] = AGL_RENDERER_ATI_ID;
+	//(*pixelFormatList)[i++] = AGL_RENDERER_GENERIC_ID|AGL_RENDERER_ATI_ID;	// VooDoo?
+	
+	(*pixelFormatList)[i++] = AGL_DEPTH_SIZE;
+	(*pixelFormatList)[i++] = 16;
+	
+	if(isRGBA!=0)
+		(*pixelFormatList)[i++] = AGL_RGBA;
+	
+	if(doubleBuffer!=0)
+		(*pixelFormatList)[i++] = AGL_DOUBLEBUFFER;
+	
+	if(stereo!=0)
+		(*pixelFormatList)[i++] = AGL_STEREO;
+	
+	if(stencilBits>0)
+	{
+		(*pixelFormatList)[i++] = AGL_STENCIL_SIZE;
+		(*pixelFormatList)[i++] = stencilBits;
+	}
+	
+	if(accumSize>0)
+	{
+		(*pixelFormatList)[i++] = AGL_ACCUM_RED_SIZE;
+		(*pixelFormatList)[i++] = accumSize;
+		(*pixelFormatList)[i++] = AGL_ACCUM_GREEN_SIZE;
+		(*pixelFormatList)[i++] = accumSize;
+		(*pixelFormatList)[i++] = AGL_ACCUM_BLUE_SIZE;
+		(*pixelFormatList)[i++] = accumSize;
+		if(isRGBA)
+		{
+			(*pixelFormatList)[i++] = AGL_ACCUM_ALPHA_SIZE;
+			(*pixelFormatList)[i++] = accumSize;
+		}
+	}
+
+	if(isOffScr!=0)
+	{
+		(*pixelFormatList)[i++] = AGL_OFFSCREEN;
+		(*pixelFormatList)[i++] = AGL_PIXEL_SIZE;
+		(*pixelFormatList)[i++] = pixelsize;
+	}
+	(*pixelFormatList)[i++] = AGL_NONE;
+}
+
+//
+// printPixelFormat
+//
+static void printPixelFormat(JNIEnv *env, GLint pixelFormatList[PIXEL_FROMAT_LIST_SIZE])
+{
+	fprintf(stderr, "attributes of pixel format lists \n");
+	fprintf(stderr, "	renderer ID:     0x%X \n", pixelFormatList[1]);
+	fprintf(stderr, "	z buffer depth:   %d \n", pixelFormatList[3]);
+	fprintf(stderr, "	double buffer:    %d \n", (pixelFormatList[5]==AGL_DOUBLEBUFFER));
+	fprintf(stderr, "	stereo:           %d \n", (pixelFormatList[6]==AGL_STEREO));
+	
+	fprintf(stderr, "attributes of pixel format lists in raw format \n");
+	fprintf(stderr, "	0:	 %d \n", pixelFormatList[0]);
+	fprintf(stderr, "	1:	 %d \n", pixelFormatList[1]);
+	fprintf(stderr, "	2:	 %d \n", pixelFormatList[2]);
+	fprintf(stderr, "	3:	 %d \n", pixelFormatList[3]);
+	fprintf(stderr, "	4:	 %d \n", pixelFormatList[4]);
+	fprintf(stderr, "	5:	 %d \n", pixelFormatList[5]);
+	fprintf(stderr, "	6:	 %d \n", pixelFormatList[6]);
+	fprintf(stderr, "	7:	 %d \n", pixelFormatList[7]);
+	fprintf(stderr, "	8:	 %d \n", pixelFormatList[8]);
+	fprintf(stderr, "	9:	 %d \n", pixelFormatList[9]);
+	fprintf(stderr, "	10:	 %d \n", pixelFormatList[10]);
+}
+
+//
+// isColorARGB
+//
+static GLboolean isColorARGB(JNIEnv *env, GLint colorModes)
+{
+	GLboolean isARGB = GL_FALSE;
+	
+	
+	if ((colorModes&AGL_ARGB16161616_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_ARGB12121212_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB101010_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_ARGB2101010_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB888_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_ARGB8888_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB565_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB555_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_ARGB1555_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB444_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_ARGB4444_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB332_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_BGR233_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB8_A8_BIT) != 0)
+	{
+		isARGB = GL_TRUE;
+	}
+	
+	return isARGB;
+}
+
+//
+// isColorRGB
+//
+static GLboolean isColorRGB(JNIEnv *env, GLint colorModes)
+{
+	GLboolean isRGB = GL_FALSE;
+	
+	
+	if ((colorModes&AGL_RGB161616_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB121212_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB101010_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB888_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB565_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB555_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB444_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB332_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_BGR233_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	else if ((colorModes&AGL_RGB8_BIT) != 0)
+	{
+		isRGB = GL_TRUE;
+	}
+	
+	return isRGB;
+}
+	
+//
+// chooseBestColor
+//
+static GLint chooseBestColor(JNIEnv *env, GLint colorModes)
+{
+	GLint best = 0;
+	
+	
+	if ((colorModes&AGL_ARGB16161616_BIT) != 0)
+	{
+		best = AGL_ARGB16161616_BIT;
+	}
+	else if ((colorModes&AGL_RGB161616_BIT) != 0)
+	{
+		best = AGL_RGB161616_BIT;
+	}
+	else if ((colorModes&AGL_ARGB12121212_BIT) != 0)
+	{
+		best = AGL_ARGB12121212_BIT;
+	}
+	else if ((colorModes&AGL_RGB121212_BIT) != 0)
+	{
+		best = AGL_RGB121212_BIT;
+	}
+	else if ((colorModes&AGL_RGB101010_A8_BIT) != 0)
+	{
+		best = AGL_RGB101010_A8_BIT;
+	}
+	else if ((colorModes&AGL_ARGB2101010_BIT) != 0)
+	{
+		best = AGL_ARGB2101010_BIT;
+	}
+	else if ((colorModes&AGL_RGB101010_BIT) != 0)
+	{
+		best = AGL_RGB101010_BIT;
+	}
+	else if ((colorModes&AGL_RGB888_A8_BIT) != 0)
+	{
+		best = AGL_RGB888_A8_BIT;
+	}
+	else if ((colorModes&AGL_ARGB8888_BIT) != 0)
+	{
+		best = AGL_ARGB8888_BIT;
+	}
+	else if ((colorModes&AGL_RGB888_BIT) != 0)
+	{
+		best = AGL_RGB888_BIT;
+	}
+	else if ((colorModes&AGL_RGB565_A8_BIT) != 0)
+	{
+		best = AGL_RGB565_A8_BIT;
+	}
+	else if ((colorModes&AGL_RGB565_BIT) != 0)
+	{
+		best = AGL_RGB565_BIT;
+	}
+	else if ((colorModes&AGL_RGB555_A8_BIT) != 0)
+	{
+		best = AGL_RGB555_A8_BIT;
+	}
+	else if ((colorModes&AGL_ARGB1555_BIT) != 0)
+	{
+		best = AGL_ARGB1555_BIT;
+	}
+	else if ((colorModes&AGL_RGB555_BIT) != 0)
+	{
+		best = AGL_RGB555_BIT;
+	}
+	else if ((colorModes&AGL_RGB444_A8_BIT) != 0)
+	{
+		best = AGL_RGB444_A8_BIT;
+	}
+	else if ((colorModes&AGL_ARGB4444_BIT) != 0)
+	{
+		best = AGL_ARGB4444_BIT;
+	}
+	else if ((colorModes&AGL_RGB444_BIT) != 0)
+	{
+		best = AGL_RGB444_BIT;
+	}
+	else if ((colorModes&AGL_RGB332_A8_BIT) != 0)
+	{
+		best = AGL_RGB332_A8_BIT;
+	}
+	else if ((colorModes&AGL_RGB332_BIT) != 0)
+	{
+		best = AGL_RGB332_BIT;
+	}
+	else if ((colorModes&AGL_BGR233_A8_BIT) != 0)
+	{
+		best = AGL_BGR233_A8_BIT;
+	}
+	else if ((colorModes&AGL_BGR233_BIT) != 0)
+	{
+		best = AGL_BGR233_BIT;
+	}
+	else if ((colorModes&AGL_RGB8_A8_BIT) != 0)
+	{
+		best = AGL_RGB8_A8_BIT;
+	}
+	else if ((colorModes&AGL_RGB8_BIT) != 0)
+	{
+		best = AGL_RGB8_BIT;
+	}
+/*
+	else if ((colorModes&AGL_INDEX16_BIT) != 0)
+	{
+		best = AGL_INDEX16_BIT;
+	}
+	else if ((colorModes&AGL_INDEX8_BIT) != 0)
+	{
+		best = AGL_INDEX8_BIT;
+	}
+	
+*/
+	return best;
+}
+
+//
+// chooseBestDepth
+//
+static GLint chooseBestDepth(JNIEnv *env, GLint depthModes)
+{
+	GLint best = 0;
+	
+	
+	if ((depthModes&AGL_128_BIT) != 0)
+	{
+		best = AGL_128_BIT;
+	}
+	else if ((depthModes&AGL_96_BIT) != 0)
+	{
+		best = AGL_96_BIT;
+	}
+	else if ((depthModes&AGL_64_BIT) != 0)
+	{
+		best = AGL_64_BIT;
+	}
+	else if ((depthModes&AGL_48_BIT) != 0)
+	{
+		best = AGL_48_BIT;
+	}
+	else if ((depthModes&AGL_32_BIT) != 0)
+	{
+		best = AGL_32_BIT;
+	}
+	else if ((depthModes&AGL_24_BIT) != 0)
+	{
+		best = AGL_24_BIT;
+	}
+	else if ((depthModes&AGL_16_BIT) != 0)
+	{
+		best = AGL_16_BIT;
+	}
+	else if ((depthModes&AGL_12_BIT) != 0)
+	{
+		best = AGL_12_BIT;
+	}
+	else if ((depthModes&AGL_10_BIT) != 0)
+	{
+		best = AGL_10_BIT;
+	}
+	else if ((depthModes&AGL_8_BIT) != 0)
+	{
+		best = AGL_8_BIT;
+	}
+	else if ((depthModes&AGL_6_BIT) != 0)
+	{
+		best = AGL_6_BIT;
+	}
+	else if ((depthModes&AGL_5_BIT) != 0)
+	{
+		best = AGL_5_BIT;
+	}
+	else if ((depthModes&AGL_4_BIT) != 0)
+	{
+		best = AGL_4_BIT;
+	}
+	else if ((depthModes&AGL_3_BIT) != 0)
+	{
+		best = AGL_3_BIT;
+	}
+	else if ((depthModes&AGL_2_BIT) != 0)
+	{
+		best = AGL_2_BIT;
+	}
+	else if ((depthModes&AGL_1_BIT) != 0)
+	{
+		best = AGL_1_BIT;
+	}
+	else if ((depthModes&AGL_0_BIT) != 0)
+	{
+		best = AGL_0_BIT;
+	}
+		
+	return best;
+}
+
+//
+// mapAGLDepth2DecDepth
+//
+static GLint mapAGLDepth2DecDepth(JNIEnv *env, GLint depthMode)
+{
+	GLint depth = 0;
+	
+	
+	if (depthMode == AGL_128_BIT)
+	{
+		depth = 128;
+	}
+	else if (depthMode == AGL_96_BIT)
+	{
+		depth = 96;
+	}
+	else if (depthMode == AGL_64_BIT)
+	{
+		depth = 64;
+	}
+	else if (depthMode == AGL_48_BIT)
+	{
+		depth = 48;
+	}
+	else if (depthMode == AGL_32_BIT)
+	{
+		depth = 32;
+	}
+	else if (depthMode == AGL_24_BIT)
+	{
+		depth = 24;
+	}
+	else if (depthMode == AGL_16_BIT)
+	{
+		depth = 16;
+	}
+	else if (depthMode == AGL_12_BIT)
+	{
+		depth = 12;
+	}
+	else if (depthMode == AGL_10_BIT)
+	{
+		depth = 10;
+	}
+	else if (depthMode == AGL_8_BIT)
+	{
+		depth = 8;
+	}
+	else if (depthMode == AGL_6_BIT)
+	{
+		depth = 6;
+	}
+	else if (depthMode == AGL_5_BIT)
+	{
+		depth = 5;
+	}
+	else if (depthMode == AGL_4_BIT)
+	{
+		depth = 4;
+	}
+	else if (depthMode == AGL_3_BIT)
+	{
+		depth = 3;
+	}
+	else if (depthMode == AGL_2_BIT)
+	{
+		depth = 2;
+	}
+	else if (depthMode == AGL_1_BIT)
+	{
+		depth = 1;
+	}
+	else if (depthMode == AGL_0_BIT)
+	{
+		depth = 0;
+	}
+	
+	return depth;
+}
+
+//
+// getRenderersInfo
+//
+static void getRenderersInfo(JNIEnv *env, RenderersInfoRectPtr info)
+{
+	UInt32			count			= 0;
+	AGLRendererInfo renderInfo		= nil,
+					renderInfoHead	= nil;
+	GDHandle		device			= GetMainDevice();
+	GLint			returnedInfo	= 0;
+	//THz				saveZone		= GetZone();
+	
+	
+	count = 0;
+	renderInfoHead = aglQueryRendererInfo(&device, 1);
+	renderInfo = renderInfoHead;
+ 	while (renderInfo != nil)
+ 	{
+	    renderInfo = aglNextRendererInfo(renderInfo);	    
+ 		count++;
+ 	}
+ 	aglDestroyRendererInfo(renderInfoHead);
+ 	
+ 	info->count = count;
+	//SetZone(SystemZone());
+ 	info->info = (RendererRectPtr)NewPtrClear(info->count * sizeof(RendererRect));
+	//SetZone(saveZone);
+ 	
+	count = 0;
+	renderInfoHead = aglQueryRendererInfo(&device, 1);
+	renderInfo = renderInfoHead;
+ 	while (renderInfo != nil)
+ 	{
+ 		info->info[count].valid = GL_TRUE;
+ 		
+		aglDescribeRenderer(renderInfo, AGL_RENDERER_ID, &returnedInfo);
+		info->info[count].id = returnedInfo;
+				
+		aglDescribeRenderer(renderInfo, AGL_ACCELERATED, &returnedInfo);
+		info->info[count].accelerated = (GLboolean)returnedInfo;
+		
+		aglDescribeRenderer(renderInfo, AGL_BUFFER_MODES, &returnedInfo);
+		info->info[count].singleBuffer	= (GLboolean)((returnedInfo&AGL_SINGLEBUFFER_BIT)!=0);
+		info->info[count].doubleBuffer	= (GLboolean)((returnedInfo&AGL_DOUBLEBUFFER_BIT)!=0);
+		info->info[count].mono			= (GLboolean)((returnedInfo&AGL_MONOSCOPIC_BIT)!=0);
+		info->info[count].stereo		= (GLboolean)((returnedInfo&AGL_STEREOSCOPIC_BIT)!=0);
+		
+		aglDescribeRenderer(renderInfo, AGL_COLOR_MODES, &returnedInfo);
+		info->info[count].colorModes = returnedInfo;
+		
+		aglDescribeRenderer(renderInfo, AGL_DEPTH_MODES, &returnedInfo);
+		info->info[count].depthModes = returnedInfo;
+		
+		aglDescribeRenderer(renderInfo, AGL_STENCIL_MODES, &returnedInfo);
+		info->info[count].stencilModes = returnedInfo;		
+
+		aglDescribeRenderer(renderInfo, AGL_ACCUM_MODES, &returnedInfo);
+		info->info[count].accumModes = returnedInfo;		
+		
+		renderInfo = aglNextRendererInfo(renderInfo);
+		count++;
+ 	}
+ 	aglDestroyRendererInfo(renderInfoHead);
+}
+
+//
+// printRendererInfo
+//
+static void printRawRendererInfo(JNIEnv *env, RendererRect info)
+{
+	fprintf(stderr, "renderer info \n");
+	fprintf(stderr, "	valid:         %d \n", info.valid);
+	fprintf(stderr, "	ID:           0x%X \n", info.id);
+	fprintf(stderr, "	accelerated:   %d \n", info.accelerated);
+	fprintf(stderr, "	depthModes:    %d \n", info.depthModes);
+	fprintf(stderr, "	colorModes:    %d \n", info.colorModes);
+	fprintf(stderr, "	stencilModes:  %d \n", info.stencilModes);
+	fprintf(stderr, "	singleBuffer:  %d \n", info.singleBuffer);
+	fprintf(stderr, "	doubleBuffer:  %d \n", info.doubleBuffer);
+	fprintf(stderr, "	mono:          %d \n", info.mono);
+	fprintf(stderr, "	stereo:        %d \n", info.stereo);
+}
+
+//
+// chooseBestRenderer
+//
+static void chooseBestRenderer(JNIEnv *env, RenderersInfoRectPtr info, 
+			       jboolean verbose, jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize,
+			       jboolean isOffScr, jboolean forceSWRenderer)
+{
+	int i=0, help=0;
+	UInt32 		count, listIndex= 0; 
+	GLboolean	haveAcceleratedRenderer		= GL_FALSE,
+		        haveValidRenderer		= GL_FALSE,
+			chooseNewPixelFormat		= GL_FALSE;
+	
+	
+	for (count=0; count<(info->count); count++)
+	{
+		info->info[count].valid = 
+		  info->info[count].valid && 
+		  (isColorARGB(env, info->info[count].colorModes) == GL_TRUE);
+		
+		if (*doubleBuffer == JNI_TRUE)
+		{
+			info->info[count].valid = 
+				info->info[count].valid && 
+				(info->info[count].doubleBuffer == GL_TRUE);
+		}
+		
+		if (*stereo == JNI_TRUE)
+		{
+			// there are no stereoscopic OpenGL renderers 
+			// for mac avaialable yet
+			// no reason to reject a 
+			// (possibly hardware accelerated) 
+			// renderer just because of that
+			//info->info[count].valid = 
+			//   info->info[count].valid && 
+			//   (info->info[count].stereo == GL_TRUE);
+		}
+		
+		haveAcceleratedRenderer = 
+				 haveAcceleratedRenderer || 
+				 (info->info[count].accelerated == GL_TRUE);
+
+		haveValidRenderer = haveValidRenderer || 
+				    (info->info[count].valid == GL_TRUE);
+	}
+	
+	// first look for an accelerated renderer
+	if (chooseNewPixelFormat == GL_FALSE)
+	{
+		count = 0;
+		while (count < info->count)
+		{
+			if (  (info->info[count].valid == GL_TRUE) && 
+			      (
+			        (
+			          (info->info[count].accelerated == GL_TRUE)  &&
+				  forceSWRenderer==JNI_FALSE
+			        ) || (
+			          (info->info[count].accelerated == GL_FALSE) &&
+				  forceSWRenderer==JNI_TRUE
+			        ) 
+			      ) 
+			   )
+			{
+				chooseNewPixelFormat = GL_TRUE;
+
+				// hardware accelerated (VooDoo, ATI?) 
+				// renderer doesn't work without it ??
+				if( info->info[count].accelerated == GL_TRUE )
+					*doubleBuffer = JNI_TRUE;	
+				
+				break;
+			}
+			
+			count++;
+		}
+	}
+	
+	// now look for any renderer
+	if (chooseNewPixelFormat == GL_FALSE)
+	{
+		count = 0;
+		while (count < info->count)
+		{
+			if (info->info[count].valid == GL_TRUE)
+			{
+				chooseNewPixelFormat = GL_TRUE;
+				
+				break;
+			}
+			
+			count++;
+		}
+	}
+	
+	if (chooseNewPixelFormat == GL_TRUE)
+	{
+		info->attributeList[i++] = AGL_RENDERER_ID;
+		info->attributeList[i++] = info->info[count].id;
+		
+		info->attributeList[i++] = AGL_DEPTH_SIZE;
+		info->attributeList[i++] = 
+		  mapAGLDepth2DecDepth(env, 
+		         chooseBestDepth(env, info->info[count].depthModes));
+
+		// if we want RGB mode, but none is avaiable,
+		// we do choose RGBA !
+		if(*isRGBA==JNI_FALSE && 
+		   !isColorRGB(env, info->info[count].colorModes))
+			*isRGBA=JNI_TRUE;
+			
+		if(*isRGBA==JNI_TRUE && 
+		   isColorARGB(env, info->info[count].colorModes))
+		{
+			info->attributeList[i++] = AGL_RGBA;
+		} else {
+			*isRGBA=JNI_FALSE;
+		}
+		
+		listIndex = i;
+		
+		if ( (*doubleBuffer == JNI_TRUE) && 
+		     (info->info[count].doubleBuffer == GL_TRUE)
+		   )
+		{
+			info->attributeList[listIndex++] = AGL_DOUBLEBUFFER;
+		}
+		else
+		{
+			*doubleBuffer = JNI_FALSE;
+		}
+		
+		if ( (*stereo == JNI_TRUE) && 
+		     (info->info[count].stereo == GL_TRUE)
+		   )
+		{
+			info->attributeList[listIndex++] = AGL_STEREO;
+		}
+		else
+		{
+			*stereo = JNI_FALSE;
+		}
+
+		if ( (*stencilBits > 0) && 
+		     (info->info[count].stencilModes != 0)
+		   )
+		{
+			info->attributeList[listIndex++] = AGL_STENCIL_SIZE;
+			info->attributeList[listIndex++] = *stencilBits;
+		}
+		else
+		{
+			*stencilBits = 0;
+		}
+
+		if ( (*accumSize > 0) && 
+		     (info->info[count].accumModes != 0)
+		   )
+		{
+			info->attributeList[listIndex++] = AGL_ACCUM_RED_SIZE;
+			info->attributeList[listIndex++] = *accumSize;
+			info->attributeList[listIndex++] = AGL_ACCUM_GREEN_SIZE;
+			info->attributeList[listIndex++] = *accumSize;
+			info->attributeList[listIndex++] = AGL_ACCUM_BLUE_SIZE;
+			info->attributeList[listIndex++] = *accumSize;
+			if(isRGBA)
+			{
+				info->attributeList[listIndex++] = 
+					AGL_ACCUM_ALPHA_SIZE;
+				info->attributeList[listIndex++] = 
+					*accumSize;
+			}
+		} else {
+			*accumSize=0;
+		}
+		
+		if(isOffScr!=0)
+			info->attributeList[listIndex++] = AGL_OFFSCREEN;
+		
+		info->attributeList[listIndex++] = AGL_NONE;
+	}
+	
+	DisposePtr((Ptr)info->info);
+	info->info = nil;
+}
+
+#pragma mark -
+
+//
+// printBufferModes
+//
+static void printBufferModes(JNIEnv *env, GLint v)
+{
+	if(v & AGL_MONOSCOPIC_BIT)   fprintf(stderr, "            AGL_MONOSCOPIC_BIT \n");
+	if(v & AGL_STEREOSCOPIC_BIT) fprintf(stderr, "            AGL_STEREOSCOPIC_BIT \n");
+	if(v & AGL_SINGLEBUFFER_BIT) fprintf(stderr, "            AGL_SINGLEBUFFER_BIT \n");
+	if(v & AGL_DOUBLEBUFFER_BIT) fprintf(stderr, "            AGL_DOUBLEBUFFER_BIT \n");
+}
+
+//
+// printColorModes
+//
+static void printColorModes(JNIEnv *env, GLint v)
+{
+	if(v & AGL_RGB8_BIT)         fprintf(stderr, "            AGL_RGB8_BIT \n");
+	if(v & AGL_RGB8_A8_BIT)      fprintf(stderr, "            AGL_RGB8_A8_BIT \n");
+	if(v & AGL_BGR233_BIT)       fprintf(stderr, "            AGL_BGR233_BIT \n");
+	if(v & AGL_BGR233_A8_BIT)    fprintf(stderr, "            AGL_BGR233_A8_BIT \n");
+	if(v & AGL_RGB332_BIT)       fprintf(stderr, "            AGL_RGB332_BIT \n");
+	if(v & AGL_RGB332_A8_BIT)    fprintf(stderr, "            AGL_RGB332_A8_BIT \n");
+	if(v & AGL_RGB444_BIT)       fprintf(stderr, "            AGL_RGB444_BIT \n");
+	if(v & AGL_ARGB4444_BIT)     fprintf(stderr, "            AGL_ARGB4444_BIT \n");
+	if(v & AGL_RGB444_A8_BIT)    fprintf(stderr, "            AGL_RGB444_A8_BIT \n");
+	if(v & AGL_RGB555_BIT)       fprintf(stderr, "            AGL_RGB555_BIT \n");
+	if(v & AGL_ARGB1555_BIT)     fprintf(stderr, "            AGL_ARGB1555_BIT \n");
+	if(v & AGL_RGB555_A8_BIT)    fprintf(stderr, "            AGL_RGB555_A8_BIT \n");
+	if(v & AGL_RGB565_BIT)       fprintf(stderr, "            AGL_RGB565_BIT \n");
+	if(v & AGL_RGB565_A8_BIT)    fprintf(stderr, "            AGL_RGB565_A8_BIT \n");
+	if(v & AGL_RGB888_BIT)       fprintf(stderr, "            AGL_RGB888_BIT \n");
+	if(v & AGL_ARGB8888_BIT)     fprintf(stderr, "            AGL_ARGB8888_BIT \n");
+	if(v & AGL_RGB888_A8_BIT)    fprintf(stderr, "            AGL_RGB888_A8_BIT \n");
+	if(v & AGL_RGB101010_BIT)    fprintf(stderr, "            AGL_RGB101010_BIT \n");
+	if(v & AGL_ARGB2101010_BIT)  fprintf(stderr, "            AGL_ARGB2101010_BIT \n");
+	if(v & AGL_RGB101010_A8_BIT) fprintf(stderr, "            AGL_RGB101010_A8_BIT \n");
+	if(v & AGL_RGB121212_BIT)    fprintf(stderr, "            AGL_RGB121212_BIT \n");
+	if(v & AGL_ARGB12121212_BIT) fprintf(stderr, "            AGL_ARGB12121212_BIT \n");
+	if(v & AGL_RGB161616_BIT)    fprintf(stderr, "            AGL_RGB161616_BIT \n");
+	if(v & AGL_ARGB16161616_BIT) fprintf(stderr, "            AGL_ARGB16161616_BIT \n");
+	if(v & AGL_INDEX8_BIT)       fprintf(stderr, "            AGL_INDEX8_BIT \n");
+	if(v & AGL_INDEX16_BIT)      fprintf(stderr, "            AGL_INDEX16_BIT \n");
+}
+
+//
+// printBitModes
+//
+static void printBitModes(JNIEnv *env, GLint v)
+{
+	if(v & AGL_0_BIT)            fprintf(stderr, "            AGL_0_BIT \n");
+	if(v & AGL_1_BIT)            fprintf(stderr, "            AGL_1_BIT \n");
+	if(v & AGL_2_BIT)            fprintf(stderr, "            AGL_2_BIT \n");
+	if(v & AGL_3_BIT)            fprintf(stderr, "            AGL_3_BIT \n");
+	if(v & AGL_4_BIT)            fprintf(stderr, "            AGL_4_BIT \n");
+	if(v & AGL_5_BIT)            fprintf(stderr, "            AGL_5_BIT \n");
+	if(v & AGL_6_BIT)            fprintf(stderr, "            AGL_6_BIT \n");
+	if(v & AGL_8_BIT)            fprintf(stderr, "            AGL_8_BIT \n");
+	if(v & AGL_10_BIT)           fprintf(stderr, "            AGL_10_BIT \n");
+	if(v & AGL_12_BIT)           fprintf(stderr, "            AGL_12_BIT \n");
+	if(v & AGL_16_BIT)           fprintf(stderr, "            AGL_16_BIT \n");
+	if(v & AGL_24_BIT)           fprintf(stderr, "            AGL_24_BIT \n");
+	if(v & AGL_32_BIT)           fprintf(stderr, "            AGL_32_BIT \n");
+	if(v & AGL_48_BIT)           fprintf(stderr, "            AGL_48_BIT \n");
+	if(v & AGL_64_BIT)           fprintf(stderr, "            AGL_64_BIT \n");
+	if(v & AGL_96_BIT)           fprintf(stderr, "            AGL_96_BIT \n");
+	if(v & AGL_128_BIT)          fprintf(stderr, "            AGL_128_BIT \n");
+}
+
+//
+// printRendererInfo
+//
+static void printRendererInfo(JNIEnv *env, AGLRendererInfo info)
+{
+	GLint rv;
+	
+	
+	aglDescribeRenderer(info, AGL_RENDERER_ID, &rv);
+	fprintf(stderr, "        AGL_RENDERER_ID     : 0x%X \n", rv);
+	
+	aglDescribeRenderer(info, AGL_OFFSCREEN, &rv);
+	fprintf(stderr, "        AGL_OFFSCREEN       : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_FULLSCREEN, &rv);
+	fprintf(stderr, "        AGL_FULLSCREEN      : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_WINDOW, &rv);
+	fprintf(stderr, "        AGL_WINDOW          : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_ACCELERATED, &rv);
+	fprintf(stderr, "        AGL_ACCELERATED     : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_ROBUST, &rv);
+	fprintf(stderr, "        AGL_ROBUST          : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_BACKING_STORE, &rv);
+	fprintf(stderr, "        AGL_BACKING_STORE   : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_MP_SAFE, &rv);
+	fprintf(stderr, "        AGL_MP_SAFE         : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_COMPLIANT, &rv);
+	fprintf(stderr, "        AGL_COMPLIANT       : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_MULTISCREEN, &rv);
+	fprintf(stderr, "        AGL_MULTISCREEN     : %s \n", (rv ? "GL_TRUE" : "GL_FALSE"));
+	
+	aglDescribeRenderer(info, AGL_BUFFER_MODES, &rv);
+	fprintf(stderr, "        AGL_BUFFER_MODES    : 0x%X \n", rv);
+	printBufferModes(env, rv);
+	
+	aglDescribeRenderer(info, AGL_MIN_LEVEL, &rv);
+	fprintf(stderr, "        AGL_MIN_LEVEL       :  %d \n", rv);
+	
+	aglDescribeRenderer(info, AGL_MAX_LEVEL, &rv);
+	fprintf(stderr, "        AGL_MAX_LEVEL       :  %d \n", rv);
+	
+	aglDescribeRenderer(info, AGL_COLOR_MODES, &rv);
+	fprintf(stderr, "        AGL_COLOR_MODES     : 0x%X \n", rv);
+	printColorModes(env, rv);
+	
+	aglDescribeRenderer(info, AGL_ACCUM_MODES, &rv);
+	fprintf(stderr, "        AGL_ACCUM_MODES     : 0x%X \n", rv);
+	printColorModes(env, rv);
+	
+	aglDescribeRenderer(info, AGL_DEPTH_MODES, &rv);
+	fprintf(stderr, "        AGL_DEPTH_MODES     : 0x%X \n", rv);
+	printBitModes(env, rv);
+	
+	aglDescribeRenderer(info, AGL_STENCIL_MODES, &rv);
+	fprintf(stderr, "        AGL_STENCIL_MODES   : 0x%X \n", rv);
+	printBitModes(env, rv);
+	
+	aglDescribeRenderer(info, AGL_MAX_AUX_BUFFERS, &rv);
+	fprintf(stderr, "        AGL_MAX_AUX_BUFFERS :  %d \n", rv);
+	
+	aglDescribeRenderer(info, AGL_VIDEO_MEMORY, &rv);
+	fprintf(stderr, "        AGL_VIDEO_MEMORY    :  %d \n", rv);
+	
+	aglDescribeRenderer(info, AGL_TEXTURE_MEMORY, &rv);
+	fprintf(stderr, "        AGL_TEXTURE_MEMORY  :  %d \n", rv);
+}
+
+//
+// checkGetRendererInfo
+//
+static void checkGetRendererInfo(JNIEnv *env, GDHandle device)
+{
+	AGLRendererInfo	info,
+					infoSaved;
+	GLint			inum;
+	
+	
+	info =  aglQueryRendererInfo(&device, 1);
+	if (info == nil)
+	{
+		fprintf(stderr, "aglQueryRendererInfo : Info Error \n");
+		return;
+	}
+	
+	inum = 0;
+	while (info != nil)
+	{
+		fprintf(stderr, "    Renderer :  %d \n", inum);
+		printRendererInfo(env, info);
+		infoSaved = info;
+		info = aglNextRendererInfo(infoSaved);
+		aglDestroyRendererInfo(infoSaved);
+		inum++;
+	}
+}
+
+//
+// printAllRenderer
+//
+static void printAllRenderer(JNIEnv *env)
+{
+	GLenum   err;
+	GDHandle device;
+	GLuint   dnum = 0;
+	
+	
+	fprintf(stderr, "the renderers that are available on this system: \n");
+	
+	err = aglGetError();
+	if (err != AGL_NO_ERROR)
+	{
+		fprintf(stderr, "aglGetError 1 - %s \n", aglErrorString(err));
+	}
+	
+	device = GetDeviceList();
+	while (device != nil)
+	{
+		fprintf(stderr, "Device :  %d \n", dnum);
+		checkGetRendererInfo(env, device);
+		device = GetNextDevice(device);
+		dnum++;
+	}
+		
+	err = aglGetError();
+	if (err != AGL_NO_ERROR)
+	{
+		fprintf(stderr, "aglGetError 2 - %s \n", aglErrorString(err));
+	}
+}
+
+
+//
+// printPixelFormatInfo
+//
+static void printPixelFormatInfo(JNIEnv *env, AGLPixelFormat info)
+{
+	GLint rv, rv1, rv2, rv3, rv4;
+	
+	aglDescribePixelFormat(info, AGL_BUFFER_SIZE, &rv);
+	fprintf(stderr, "        AGL_BUFFER_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_LEVEL, &rv);
+	fprintf(stderr, "        AGL_LEVEL     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_RGBA, &rv);
+	fprintf(stderr, "        AGL_RGBA     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_DOUBLEBUFFER, &rv);
+	fprintf(stderr, "        AGL_DOUBLEBUFFER     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_STEREO, &rv);
+	fprintf(stderr, "        AGL_STEREO     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_AUX_BUFFERS, &rv);
+	fprintf(stderr, "        AGL_AUX_BUFFERS     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_RED_SIZE, &rv);
+	fprintf(stderr, "        AGL_RED_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_GREEN_SIZE, &rv);
+	fprintf(stderr, "        AGL_GREEN_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_BLUE_SIZE, &rv);
+	fprintf(stderr, "        AGL_BLUE_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_ALPHA_SIZE, &rv);
+	fprintf(stderr, "        AGL_ALPHA_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_DEPTH_SIZE, &rv);
+	fprintf(stderr, "        AGL_DEPTH_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_STENCIL_SIZE, &rv);
+	fprintf(stderr, "        AGL_STENCIL_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_ACCUM_RED_SIZE, &rv1);
+	aglDescribePixelFormat(info, AGL_ACCUM_GREEN_SIZE, &rv2);
+	aglDescribePixelFormat(info, AGL_ACCUM_BLUE_SIZE, &rv3);
+	aglDescribePixelFormat(info, AGL_ACCUM_ALPHA_SIZE, &rv4);
+	fprintf(stderr, "        AGL_ACCUM_SIZE (rgba) : %d / %d / %d / %d \n",
+				rv1, rv2, rv3, rv4 );
+	
+	aglDescribePixelFormat(info, AGL_PIXEL_SIZE, &rv);
+	fprintf(stderr, "        AGL_PIXEL_SIZE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_OFFSCREEN, &rv);
+	fprintf(stderr, "        AGL_OFFSCREEN     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_FULLSCREEN, &rv);
+	fprintf(stderr, "        AGL_FULLSCREEN     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_WINDOW, &rv);
+	fprintf(stderr, "        AGL_WINDOW     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_RENDERER_ID, &rv);
+	fprintf(stderr, "        AGL_RENDERER_ID     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_SINGLE_RENDERER, &rv);
+	fprintf(stderr, "        AGL_SINGLE_RENDERER     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_ACCELERATED, &rv);
+	fprintf(stderr, "        AGL_ACCELERATED     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_BACKING_STORE, &rv);
+	fprintf(stderr, "        AGL_BACKING_STORE     : %d \n", rv);
+	
+	aglDescribePixelFormat(info, AGL_COMPLIANT, &rv);
+	fprintf(stderr, "        AGL_COMPLIANT     : %d \n", rv);
+}
+
+static void checkPixelFormatInfo(JNIEnv *env, AGLPixelFormat info,
+			       jboolean *doubleBuffer, 
+			       jboolean *stereo, jboolean *isRGBA,
+			       int *stencilBits, int *accumSize)
+{
+	GLint rv, rv1, rv2, rv3, rv4;
+	
+	aglDescribePixelFormat(info, AGL_RGBA, &rv);
+	*isRGBA= (rv==GL_TRUE)?JNI_TRUE:JNI_FALSE;
+
+	aglDescribePixelFormat(info, AGL_DOUBLEBUFFER, &rv);
+	*doubleBuffer= (rv==GL_TRUE)?JNI_TRUE:JNI_FALSE;
+	
+	aglDescribePixelFormat(info, AGL_STEREO, &rv);
+	*stereo = (rv==GL_TRUE)?JNI_TRUE:JNI_FALSE;
+	
+	aglDescribePixelFormat(info, AGL_STENCIL_SIZE, &rv);
+	*stencilBits = (rv==GL_TRUE)?JNI_TRUE:JNI_FALSE;
+	
+	aglDescribePixelFormat(info, AGL_ACCUM_RED_SIZE, &rv1);
+	aglDescribePixelFormat(info, AGL_ACCUM_GREEN_SIZE, &rv2);
+	aglDescribePixelFormat(info, AGL_ACCUM_BLUE_SIZE, &rv3);
+	aglDescribePixelFormat(info, AGL_ACCUM_ALPHA_SIZE, &rv4);
+	*accumSize=rv1+rv2+rv3;
+	if(*isRGBA==JNI_TRUE)
+		*accumSize+=rv4;
+}
diff --git a/CNativeCode/OpenGL_misc.c b/CNativeCode/OpenGL_misc.c
new file mode 100644
index 0000000..d2ad7c6
--- /dev/null
+++ b/CNativeCode/OpenGL_misc.c
@@ -0,0 +1,887 @@
+
+#include "OpenGL_misc.h"
+#include "gl4java_GLContext.h"
+
+#ifdef _X11_
+	#include <GL/glx.h>
+	#include <dlfcn.h>
+#endif
+
+#ifdef macintosh
+	#include <agl.h>
+	#include <string.h>
+	#include <CodeFragments.h>
+	#include <Errors.h>
+	#include <TextUtils.h>
+	#include <StringCompare.h>
+	#include "mac_console.h"
+	
+	#define fragNoErr 0
+#endif
+
+static const char * _lib_version_=  __LIB_VERSION__ ;
+
+#ifdef macintosh
+  static const char * _lib_vendor_ = "Jausoft - Sven Goethel Software Development & Gerard Ziemski"; 
+#else
+  static const char * _lib_vendor_ = "Jausoft - Sven Goethel Software Development"; 
+#endif
+
+#ifndef LIBAPIENTRY
+	#define LIBAPIENTRY
+#endif
+#ifndef LIBAPI
+	#define LIBAPI
+#endif
+#ifndef CALLBACK
+	#define CALLBACK
+#endif
+
+jboolean testJavaGLTypes(jboolean verbose);
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM * vm, void *reserved);
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved);
+
+jboolean testJavaGLTypes(jboolean verbose)
+{
+    jboolean ret=JNI_TRUE;
+    jint i1 = (jint)0xaaff;
+    jint i2 = 0;
+    jlong l1 = (jlong)i1;
+    i2 = (jint)l1;
+
+    if(i1!=i2)
+    {
+        fprintf(stderr,"(jint)((jlong)0xaaff) != (jint)0xaaff\n");
+	ret = JNI_FALSE;
+    }
+
+    /* NON DEPENDENCE CHECKS */
+
+    /* NOW LET's CHECK THE TAKEN JNI-TYPE <-> GL-TYPE MAPPING */
+
+    if( sizeof(GLUtriangulatorObj *) > sizeof(jlong) )
+    {
+        fprintf(stderr,"(GLUtriangulatorObj *) > (jlong)\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLUnurbsObj *) > sizeof(jlong) )
+    {
+        fprintf(stderr,"(GLUnurbsObj *) > (jlong)\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLUquadricObj *) > sizeof(jlong) )
+    {
+        fprintf(stderr,"(GLUquadricObj *) > (jlong)\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLvoid *) > sizeof(jbyte *) )
+    {
+        fprintf(stderr,"(GLvoid *) > (jbyte *)\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLbyte) != sizeof(jbyte) )
+    {
+        fprintf(stderr,"GLbyte != jbyte\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLshort) != sizeof(jshort) )
+    {
+        fprintf(stderr,"GLshort != jshort\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLint) != sizeof(jint) )
+    {
+        fprintf(stderr,"GLint != jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLsizei) != sizeof(jint) )
+    {
+        fprintf(stderr,"GLsizei != jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLfloat) != sizeof(jfloat) )
+    {
+        fprintf(stderr,"GLfloat != jfloat\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLclampf) != sizeof(jfloat) )
+    {
+        fprintf(stderr,"GLclampf != jfloat\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLdouble) != sizeof(jdouble) )
+    {
+        fprintf(stderr,"GLdouble != jdouble\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLclampd) != sizeof(jdouble) )
+    {
+        fprintf(stderr,"GLclampd != jdouble\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLubyte) != sizeof(jbyte) )
+    {
+        fprintf(stderr,"GLubyte != jboolean\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLboolean) != sizeof(jboolean) )
+    {
+        fprintf(stderr,"GLboolean != jboolean\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLushort) != sizeof(jshort) )
+    {
+        fprintf(stderr,"GLushort != jshort\n");
+	ret = JNI_FALSE;
+    }
+
+    /* NOT DEF'ed IN JNI
+     *
+     * GLuint, GLenum : 32-bit unsigned integer
+     * GLbitfield     :       dito.
+     */
+
+    if( sizeof(void *) > sizeof(jlong) )
+    {
+        fprintf(stderr,"(void *) > (jlong)\n");
+	ret = JNI_FALSE;
+    }
+
+    if( sizeof(GLuint) != sizeof(jint) )
+    {
+        fprintf(stderr,"GLuint != jint\n");
+	ret = JNI_FALSE;
+    }
+    if( sizeof(GLenum) != sizeof(jint) )
+    {
+        fprintf(stderr,"GLenum != jint\n");
+	ret = JNI_FALSE;
+    }
+    if( sizeof(GLbitfield) != sizeof(jint) )
+    {
+        fprintf(stderr,"GLbitfield != jint\n");
+	ret = JNI_FALSE;
+    }
+
+    if(ret==JNI_FALSE)
+    {
+	fflush(stderr);
+    }
+
+    /* VERBOSE/ERROR DUMP OF GL Types */
+
+    if(JNI_FALSE==verbose && ret==JNI_TRUE) return ret;
+
+    fprintf(stderr,"GLbyte %d\n", sizeof(GLbyte)); 
+    fprintf(stderr,"GLshort %d\n", sizeof(GLshort)); 
+    fprintf(stderr,"GLint %d\n", sizeof(GLint)); 
+    fprintf(stderr,"GLfloat %d\n", sizeof(GLfloat)); 
+    fprintf(stderr,"GLdouble %d\n", sizeof(GLdouble)); 
+    fprintf(stderr,"GLubyte %d\n", sizeof(GLubyte)); 
+    fprintf(stderr,"GLboolean %d\n", sizeof(GLboolean)); 
+    fprintf(stderr,"GLushort %d\n", sizeof(GLushort)); 
+    fprintf(stderr,"GLuint %d\n", sizeof(GLuint)); 
+    fprintf(stderr,"GLenum %d\n", sizeof(GLenum)); 
+    fprintf(stderr,"GLbitfield %d\n", sizeof(GLbitfield)); 
+
+    fprintf(stderr,"\njboolean %d\n", sizeof(jboolean)); 
+    fprintf(stderr,"jbyte %d\n", sizeof(jbyte)); 
+    fprintf(stderr,"jchar %d\n", sizeof(jchar)); 
+    fprintf(stderr,"jshort %d\n", sizeof(jshort)); 
+    fprintf(stderr,"jint %d\n", sizeof(jint)); 
+    fprintf(stderr,"jlong %d\n", sizeof(jlong)); 
+    fprintf(stderr,"jfloat %d\n", sizeof(jfloat)); 
+    fprintf(stderr,"jdouble %d\n", sizeof(jdouble)); 
+
+    fflush(stderr);
+
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljCheckGLTypesNative(JNIEnv *env, jobject obj )
+{
+    return testJavaGLTypes(JNI_TRUE);
+}
+
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLContext_gljGetNativeLibVersionNative(JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _lib_version_);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLContext_gljGetNativeLibVendorNative(JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _lib_vendor_);
+}
+
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM * vm, void *reserved)
+{
+    return 0x00010001; /* old JDK 1.1 JNI :-) */
+}
+
+JNIEXPORT void JNICALL
+JNI_OnUnload(JavaVM *vm, void *reserved)
+{
+    /* old JNI :-) */
+}
+
+
+/**
+ * Experimental Code, not done yet !
+ * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+ */
+JNIEXPORT void JNICALL
+Java_gl4java_GLContext_gljReadPixelGL2AWT__IIIIIII_3B (
+	JNIEnv *env, jobject obj,
+	jint xpos,
+	jint ypos,
+	jint width,
+	jint height,
+	jint format,
+	jint type,
+	jint bufferName,
+	jbyteArray pixelGLDest)
+{
+	GLint swapbytes, lsbfirst, rowlength;
+	GLint skiprows, skippixels, alignment;
+	GLint unswapbytes, unlsbfirst, unrowlength;
+	GLint unskiprows, unskippixels, unalignment;
+
+	jbyte *pixelGLDestData = NULL;
+	jsize lenPixelGLDest = 0;
+
+	jboolean isCopiedArray = JNI_FALSE;
+
+	if(pixelGLDest==NULL)
+		return;
+
+	lenPixelGLDest = (*env)->GetArrayLength(env, pixelGLDest);
+	pixelGLDestData = (*env)->GetByteArrayElements(env, pixelGLDest, 
+	                                               &isCopiedArray);
+
+	/* Save current modes. */
+	glGetIntegerv(GL_PACK_SWAP_BYTES, &swapbytes);
+	glGetIntegerv(GL_PACK_LSB_FIRST, &lsbfirst);
+	glGetIntegerv(GL_PACK_ROW_LENGTH, &rowlength);
+	glGetIntegerv(GL_PACK_SKIP_ROWS, &skiprows);
+	glGetIntegerv(GL_PACK_SKIP_PIXELS, &skippixels);
+	glGetIntegerv(GL_PACK_ALIGNMENT, &alignment);
+	glGetIntegerv(GL_UNPACK_SWAP_BYTES, &unswapbytes);
+	glGetIntegerv(GL_UNPACK_LSB_FIRST, &unlsbfirst);
+	glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unrowlength);
+	glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unskiprows);
+	glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unskippixels);
+	glGetIntegerv(GL_UNPACK_ALIGNMENT, &unalignment);
+
+	/* Little endian machines (DEC Alpha, Inten X86, PPC(in LSB mode)...  
+	   for example) could benefit from setting 
+	   GL_PACK_LSB_FIRST to GL_TRUE
+	   instead of GL_FALSE, but this would require changing the
+	   generated bitmaps too. */
+	glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
+	glPixelStorei(GL_PACK_LSB_FIRST, GL_TRUE);
+        glPixelStorei(GL_PACK_ROW_LENGTH, width);
+	glPixelStorei(GL_PACK_SKIP_ROWS, 0);
+	glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+	glPixelStorei(GL_PACK_ALIGNMENT, 1);
+	glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+	glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+	/* Actually read the pixels. */
+        glReadBuffer(bufferName);
+        glReadPixels(xpos, ypos, width, height, format, type, 
+	             pixelGLDestData);
+
+	/* Restore saved modes. */
+	glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes);
+	glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst);
+	glPixelStorei(GL_PACK_ROW_LENGTH, rowlength);
+	glPixelStorei(GL_PACK_SKIP_ROWS, skiprows);
+	glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels);
+	glPixelStorei(GL_PACK_ALIGNMENT, alignment);
+	glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes);
+	glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst);
+	glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment);
+
+	glFlush();
+	glFinish();
+
+	(*env)->ReleaseByteArrayElements(env,  
+	                                 pixelGLDest, pixelGLDestData, 
+					 (isCopiedArray==JNI_TRUE)?0:JNI_ABORT);
+}
+
+/**
+ * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+ */
+JNIEXPORT void JNICALL
+Java_gl4java_GLContext_gljReadPixelGL2AWT__IIIIIII_3B_3I (
+	JNIEnv *env, jobject obj,
+	jint xpos,
+	jint ypos,
+	jint width,
+	jint height,
+	jint format,
+	jint type,
+	jint bufferName,
+	jbyteArray pixelGL,
+	jintArray pixelDest)
+{
+	GLint swapbytes, lsbfirst, rowlength;
+	GLint skiprows, skippixels, alignment;
+	GLint unswapbytes, unlsbfirst, unrowlength;
+	GLint unskiprows, unskippixels, unalignment;
+
+	jsize lenPixelSource = 0;
+	jbyte *pixelGLData = NULL;
+	jsize lenPixelDest = 0;
+	jint *pixelDestData = NULL;
+        int alpha=0;
+        int red=0;
+        int green=0;
+        int blue=0;
+        int offset=0;
+        int y_desc;
+	int x;
+
+	jboolean isCopiedArray0 = JNI_FALSE;
+	jboolean isCopiedArray1 = JNI_FALSE;
+
+	if(pixelGL==NULL || pixelDest==NULL)
+		return;
+
+	lenPixelSource = (*env)->GetArrayLength(env, pixelGL);
+	pixelGLData = (*env)->GetByteArrayElements(env, pixelGL, 
+	                                           &isCopiedArray0);
+	lenPixelDest = (*env)->GetArrayLength(env, pixelDest);
+	pixelDestData = (*env)->GetIntArrayElements(env, pixelDest, 
+	                                            &isCopiedArray1);
+
+	/* Save current modes. */
+	glGetIntegerv(GL_PACK_SWAP_BYTES, &swapbytes);
+	glGetIntegerv(GL_PACK_LSB_FIRST, &lsbfirst);
+	glGetIntegerv(GL_PACK_ROW_LENGTH, &rowlength);
+	glGetIntegerv(GL_PACK_SKIP_ROWS, &skiprows);
+	glGetIntegerv(GL_PACK_SKIP_PIXELS, &skippixels);
+	glGetIntegerv(GL_PACK_ALIGNMENT, &alignment);
+	glGetIntegerv(GL_UNPACK_SWAP_BYTES, &unswapbytes);
+	glGetIntegerv(GL_UNPACK_LSB_FIRST, &unlsbfirst);
+	glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unrowlength);
+	glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unskiprows);
+	glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unskippixels);
+	glGetIntegerv(GL_UNPACK_ALIGNMENT, &unalignment);
+
+	/* Little endian machines (DEC Alpha, Inten X86, PPC(in LSB mode)...  
+	   for example) could benefit from setting 
+	   GL_PACK_LSB_FIRST to GL_TRUE
+	   instead of GL_FALSE, but this would require changing the
+	   generated bitmaps too. */
+	glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
+	glPixelStorei(GL_PACK_LSB_FIRST, GL_TRUE);
+        glPixelStorei(GL_PACK_ROW_LENGTH, width);
+	glPixelStorei(GL_PACK_SKIP_ROWS, 0);
+	glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
+	glPixelStorei(GL_PACK_ALIGNMENT, 1);
+	glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+	glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+	/* Actually read the pixels. */
+        glReadBuffer(bufferName);
+        glReadPixels(xpos, ypos, width, height, format, type, pixelGLData);
+
+	/* Restore saved modes. */
+	glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes);
+	glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst);
+	glPixelStorei(GL_PACK_ROW_LENGTH, rowlength);
+	glPixelStorei(GL_PACK_SKIP_ROWS, skiprows);
+	glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels);
+	glPixelStorei(GL_PACK_ALIGNMENT, alignment);
+	glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes);
+	glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst);
+	glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength);
+	glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows);
+	glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels);
+	glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment);
+
+        for(y_desc=height-1; y_desc>=0; y_desc--)
+        {
+              for(x=0;x<width;x++)
+              {
+                red   = ( (int)(pixelGLData[offset++]) & 0xff ) << 16;
+                green = ( (int)(pixelGLData[offset++]) & 0xff ) <<  8;
+                blue  =   (int)(pixelGLData[offset++]) & 0xff;
+
+                if(format==GL_RGBA)
+                    alpha = ( (int)(pixelGLData[offset++]) & 0xff ) << 24;
+                else
+                    alpha = ( (int) 0xff ) << 24;
+
+                pixelDestData[y_desc*width + x] = alpha | red | green | blue;
+              }
+        }     
+
+	(*env)->ReleaseByteArrayElements(env,  pixelGL, pixelGLData, 
+	                               (isCopiedArray0==JNI_TRUE)?0:JNI_ABORT);
+
+	(*env)->ReleaseIntArrayElements(env,  pixelDest, pixelDestData, 
+	                               (isCopiedArray1==JNI_TRUE)?0:JNI_ABORT);
+}
+
+/**
+ * Experimental Code, not done yet !
+ * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+ */
+JNIEXPORT void JNICALL 
+Java_gl4java_GLContext_gljCpyOffScrnImg2Buffer__III_3B
+  (JNIEnv *env, jobject obj, jint width, jint height, jint format, jbyteArray pixelDest)
+{
+}
+
+/**
+ * Experimental Code, not done yet !
+ * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+ */
+JNIEXPORT void JNICALL 
+Java_gl4java_GLContext_gljCpyOffScrnImg2Buffer__III_3I
+  (JNIEnv *env, jobject obj, jint width, jint height, jint format, jintArray pixelDest)
+{
+#ifdef _X11_
+
+        jclass cls = 0;
+        jfieldID fpixmapHandle=0;
+
+	jsize lenPixelDest = 0;
+	jint *pixelDestData = NULL;
+	jboolean isCopiedArray = JNI_FALSE;
+	jboolean ret = JNI_TRUE;
+	int sizemax=0;
+	int sizepix=0;
+
+
+        jfieldID fdisplayHandle=0;
+        Display *disp=0;
+	Pixmap pix=0;
+        XImage *image;
+
+        cls = (*env)->GetObjectClass(env, obj);
+
+	fdisplayHandle = (*env)->GetFieldID(env, cls, "displayHandle", "I");
+	if (fdisplayHandle == 0) ret= JNI_FALSE;
+	else disp=(Display *)(*env)->GetIntField(env, obj, fdisplayHandle);
+
+	fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "I");
+	if (fpixmapHandle == 0) ret= JNI_FALSE;
+	else pix = (Pixmap)(*env)->GetIntField(env, obj, fpixmapHandle);
+
+	if(pix==0 || pixelDest==NULL)
+		return;
+
+	lenPixelDest = (*env)->GetArrayLength(env, pixelDest);
+	pixelDestData = (*env)->GetIntArrayElements(env, pixelDest, 
+	                                            &isCopiedArray);
+
+	if(format==GL_RGBA) {
+          image = XGetImage(disp, pix, 0, 0, width, height, 
+	                    0xffffffff, ZPixmap);
+          printf("format RGBA!!\n");
+	} else if(format==GL_RGB) {
+          image = XGetImage(disp, pix, 0, 0, width, height, 
+	                    0x00ffffff, ZPixmap);
+          printf("format RGB!!\n");
+	} else {
+          image = XGetImage(disp, pix, 0, 0, width, height, 
+	                    0xffffffff, ZPixmap);
+          printf("format not supported - guessing RGBA!!\n");
+	}
+
+	if(image!=NULL)
+	{
+	    printf("width %d height %d\n", (int)width, (int)height);
+	    printf("depth %d, bytes_per_line %d, width %d, height %d\n",
+	       image->depth, image->bytes_per_line, image->width, image->height);
+	    sizemax=(int)(lenPixelDest*sizeof(jint));
+	    sizepix=image->bytes_per_line*image->height;
+
+	    printf("sizeof dest-array: %d bytes\n", sizemax);
+	    printf("sizeof image bpl*height: %d bytes\n", sizepix); 
+
+	    if(sizepix<sizemax) sizemax=sizepix;
+
+	    (*env)->SetIntArrayRegion(env,  pixelDest, 0, sizemax/sizeof(jint),
+				      (jint*)image->data);
+	    printf("copied ..\n");
+	} else {
+	    printf("invalid image ...\n");
+	}
+
+	if(pixelDestData!=NULL)
+	    (*env)->ReleaseIntArrayElements(env,  pixelDest, pixelDestData, 
+	                                    JNI_ABORT);
+#endif
+}
+
+#ifdef macintosh
+
+#ifndef NDEBUG
+
+static void PrintSymbolNamesByConnection (CFragConnectionID myConnID)
+{
+       long           myIndex;
+       long           myCount;       /*number of exported symbols in fragment*/
+       OSErr          myErr;
+       Str255         myName;        /*symbol name*/
+       Ptr            myAddr;        /*symbol address*/
+       CFragSymbolClass       myClass;       /*symbol class*/
+       static char buffer[256];
+
+       myErr = CountSymbols(myConnID, &myCount);
+       if (!myErr)
+          for (myIndex = 1; myIndex <= myCount; myIndex++)
+             {
+                myErr = GetIndSymbol(myConnID, myIndex, myName, 
+                                        &myAddr, &myClass);
+                if (!myErr)
+		{
+			p2cstrcpy (buffer, myName);
+								 
+            printf("%d/%d: class %d - name %s\n", 
+		   		myIndex, myCount, myClass, buffer);
+		}
+             }
+}
+
+static Ptr SeekSymbolNamesByConnection (CFragConnectionID myConnID, Str255 name)
+{
+       long           myIndex;
+       long           myCount;       /*number of exported symbols in fragment*/
+       OSErr          myErr;
+       Str255         myName;        /*symbol name*/
+       Ptr            myAddr;        /*symbol address*/
+       CFragSymbolClass       myClass;       /*symbol class*/
+
+       myErr = CountSymbols(myConnID, &myCount);
+       if (!myErr)
+          for (myIndex = 1; myIndex <= myCount; myIndex++)
+             {
+                myErr = GetIndSymbol(myConnID, myIndex, myName, 
+                                        &myAddr, &myClass);
+                if (!myErr && EqualString (myName, name, true, true) == true )
+			return myAddr;
+             }
+}
+
+#endif /* ifndef NDEBUG */
+
+#endif /* ifdef macintosh */
+
+void * LIBAPIENTRY getGLProcAddressHelper(const char * func, int * method,
+					  int debug, int verbose )
+{
+	void * funcPtr=NULL;
+	int lmethod;
+
+#ifdef _X11_
+
+	void * libHandleGL;
+
+	/*
+	 * void (*glXGetProcAddressARB(const GLubyte *procName))
+	 */
+	static void * (CALLBACK *__glXGetProcAddress)
+					(const GLubyte *procName) = NULL;
+        static int                  __firstAccess                 = 1;
+
+        if(__glXGetProcAddress==NULL && __firstAccess)
+	{
+	    libHandleGL = dlopen("libGL.so", RTLD_LAZY|RTLD_GLOBAL);
+	    if(libHandleGL==NULL)
+	    {
+		printf("cannot access OpenGL library libGL.so\n");
+		fflush(NULL);
+	    } else {
+		__glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddressARB");
+
+		if(__glXGetProcAddress!=NULL && verbose) {
+		        printf("found glXGetProcAddressARB in libGL.so\n");
+		        fflush(NULL);
+		}
+
+		if(__glXGetProcAddress==NULL) 
+		{
+		    __glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddressEXT");
+
+		    if(__glXGetProcAddress!=NULL && verbose) {
+		        printf("found glXGetProcAddressEXT in libGL.so\n");
+		        fflush(NULL);
+		    }
+		}
+
+		if(__glXGetProcAddress==NULL) 
+		{
+		    __glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddress");
+
+		    if(__glXGetProcAddress!=NULL && verbose) {
+		        printf("found glXGetProcAddress in libGL.so\n");
+		        fflush(NULL);
+		    }
+		}
+
+		dlclose(libHandleGL);
+		libHandleGL=NULL;
+
+		if(__glXGetProcAddress==NULL)
+		{
+		    printf("cannot find glXGetProcAddress* in OpenGL library libGL.so\n");
+		    fflush(NULL);
+		    libHandleGL = dlopen("libglx.so", RTLD_LAZY|RTLD_GLOBAL);
+		    if(libHandleGL==NULL)
+		    {
+			printf("cannot access GLX library libglx.so\n");
+			fflush(NULL);
+		    } else {
+			__glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddressARB");
+
+		        if(__glXGetProcAddress!=NULL && verbose) {
+		            printf("found glXGetProcAddressARB in libglx.so\n");
+		            fflush(NULL);
+		        }
+
+			if(__glXGetProcAddress==NULL) {
+			    __glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddressEXT");
+
+		            if(__glXGetProcAddress!=NULL && verbose) {
+		                printf("found glXGetProcAddressEXT in libglx.so\n");
+		                fflush(NULL);
+		            }
+			}
+
+			if(__glXGetProcAddress==NULL) {
+			    __glXGetProcAddress = 
+				    dlsym(libHandleGL, "glXGetProcAddress");
+
+		            if(__glXGetProcAddress!=NULL && verbose) {
+		                printf("found glXGetProcAddress in libglx.so\n");
+		                fflush(NULL);
+		            }
+			}
+
+			dlclose(libHandleGL);
+			libHandleGL=NULL;
+		    }
+		}
+	    }
+	}
+        if(__glXGetProcAddress==NULL && __firstAccess)
+	{
+	    printf("cannot find glXGetProcAddress* in GLX library libglx.so\n");
+	    fflush(NULL);
+	}
+        __firstAccess = 0;
+
+        if(__glXGetProcAddress!=NULL)
+		funcPtr = __glXGetProcAddress(func);
+
+	if(funcPtr==NULL) {
+		lmethod=2;
+		libHandleGL = dlopen("libGL.so", RTLD_LAZY|RTLD_GLOBAL);
+		if(libHandleGL==NULL)
+		{
+			printf("cannot access OpenGL library libGL.so\n");
+			fflush(NULL);
+		} else {
+			funcPtr = dlsym(libHandleGL, func);
+			dlclose(libHandleGL);
+		}
+	} else lmethod=1;
+#endif
+
+
+#ifdef _WIN32_
+
+	HMODULE hDLL_OPENGL32 = 0;
+
+
+
+	funcPtr = wglGetProcAddress(func);
+	if(funcPtr==NULL)
+	{
+		lmethod=2;
+
+
+		if(hDLL_OPENGL32==NULL)
+
+		{
+			hDLL_OPENGL32 = LoadLibrary ("OPENGL32.DLL");
+
+			/* hDLL_OPENGL32 = GetModuleHandle ("OPENGL32.DLL"); */
+
+		}
+		if(hDLL_OPENGL32==NULL)
+		{
+			printf("cannot access OpenGL library OPENGL32.DLL\n");
+			fflush(NULL);
+		} else {
+			funcPtr = GetProcAddress (hDLL_OPENGL32, func);
+			FreeLibrary(hDLL_OPENGL32);
+		}
+	} else lmethod=1;
+#endif
+
+#ifdef macintosh
+   	Str255 errName;
+	Str255 funcName;
+	Ptr glLibMainAddr = 0;
+	CFragConnectionID glLibConnectId = 0;
+	CFragSymbolClass glLibSymClass = 0;
+	OSErr returnError=fragNoErr;
+	#ifndef NDEBUG
+        static int firstTime = 1;
+    #endif
+	     
+        returnError = 
+		GetSharedLibrary("\pOpenGLLibrary", 
+			       kPowerPCCFragArch, 
+			       kReferenceCFrag,
+			       &glLibConnectId, 
+			       &glLibMainAddr, 
+                   errName);
+
+	if (returnError != fragNoErr)
+	{
+        	printf ("GetSharedLibrary Err(%d): Ahhh!  Didn't find LIBRARY !\n",
+        		returnError);
+	} 
+
+	if (returnError == fragNoErr)
+	{
+		c2pstrcpy ( funcName, func );
+		
+		#ifndef NDEBUG
+		 if(firstTime)
+		 {
+			PrintSymbolNamesByConnection (glLibConnectId);
+			firstTime=0;
+		 } 
+		 funcPtr = (void *) 
+			SeekSymbolNamesByConnection (glLibConnectId, funcName);
+		#endif
+		
+		if(funcPtr==NULL)
+		{
+		  returnError = 
+		    FindSymbol (glLibConnectId, funcName, 
+		                &funcPtr, & glLibSymClass );
+		    lmethod=2;
+		} 
+		#ifndef NDEBUG
+		 else lmethod=3;
+		#endif
+		
+		if (returnError != fragNoErr)
+		{
+		  printf ("GetSharedLibrary Err(%d): Ahhh!  Didn't find SYMBOL: %s !\n",
+		  	returnError, func);
+		} 
+		returnError = fragNoErr; // fall back to ok mode ...
+	} 
+
+	if (returnError == fragNoErr && glLibConnectId!=NULL)
+	{
+		returnError = CloseConnection(&glLibConnectId);
+
+		if (returnError != fragNoErr)
+		{
+		  printf ("GetSharedLibrary Err(%d): Ahhh!  Didn't close LIBRARY !\n",
+		  	returnError);
+		} 
+	} 
+
+	
+#endif
+
+	if(funcPtr==NULL)
+	{
+	  if(debug||verbose)
+	  {
+		printf("%s (%d): not implemented !\n", func, lmethod);
+		fflush(NULL);
+	  }
+	} else if(verbose) {
+		printf("%s (%d): loaded !\n", func, lmethod);
+		fflush(NULL);
+	} 
+	if(method!=NULL) *method=lmethod;
+	return funcPtr;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljTestGLProc (
+	JNIEnv *env, jobject obj, jstring name, jboolean verbose )
+{
+     jboolean res;
+     int method=0;
+     
+     const char *str = (*env)->GetStringUTFChars(env, name, 0);
+
+     #ifdef macintosh
+     	InstallJavaConsole(env);
+     #endif
+     
+     res = ( getGLProcAddressHelper(str, &method, 0, verbose)!=NULL )?
+			JNI_TRUE:JNI_FALSE;
+
+     (*env)->ReleaseStringUTFChars(env, name, str);
+     return res;
+}
+
+
+JNIEXPORT jint JNICALL
+Java_gl4java_GLContext_gljGetCurrentContext( 
+	JNIEnv *env, jobject obj )
+{
+	#ifdef _WIN32_
+                return (jint) wglGetCurrentContext();
+        #else
+          #ifdef macintosh
+                return (jint) aglGetCurrentContext();
+          #else
+                return (jint) glXGetCurrentContext();   
+	  #endif
+        #endif
+}
+
diff --git a/CNativeCode/OpenGL_misc.h b/CNativeCode/OpenGL_misc.h
new file mode 100644
index 0000000..2312d8c
--- /dev/null
+++ b/CNativeCode/OpenGL_misc.h
@@ -0,0 +1,28 @@
+
+#ifndef OPENGLMISC
+	#define OPENGLMISC
+
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <stdarg.h>
+
+	#ifdef _WIN32_
+		#include "winstuff.h"
+	#endif
+
+	#include <jni.h>
+
+	#include<GL/gl.h>
+	#include <GL/glu.h>
+
+	#ifndef LIBAPIENTRY
+		#define LIBAPIENTRY
+	#endif
+	#ifndef LIBAPI
+		#define LIBAPI
+	#endif
+
+	LIBAPI void * LIBAPIENTRY getGLProcAddressHelper
+				         (const char * func, int * method,
+					  int debug, int verbose );
+#endif
diff --git a/CNativeCode/getProtos b/CNativeCode/getProtos
new file mode 100755
index 0000000..d133bea
--- /dev/null
+++ b/CNativeCode/getProtos
@@ -0,0 +1,11 @@
+#! /bin/sh
+
+rm a.h
+
+for i in $(cat aaa.txt); do 
+	echo looking for $i
+	sed -n "/$i(/,/);/w a.tmp.h" /usr/local/src/mesa/include/GL/gl.h
+	cat a.tmp.h >> a.h
+done 
+
+rm a.tmp.h
diff --git a/CNativeCode/jni12tools.c b/CNativeCode/jni12tools.c
new file mode 100644
index 0000000..8e2cc37
--- /dev/null
+++ b/CNativeCode/jni12tools.c
@@ -0,0 +1,516 @@
+#include <string.h>
+#include "jnitools.h"
+
+#ifdef __BUILTIN_VA_ARG_INCR
+        /* Special stuff for the SunOS port ... */
+        va_list __builtin_va_arg_incr = 0;
+        va_list __builtin_va_alist = 0;
+#endif
+
+static int isinit = 0;
+static jclass classString=0;
+static jmethodID String_getBytes_ID=0;
+static jmethodID String_init_ID=0;
+
+static int init(JNIEnv *env)
+{
+    classString = (*env)->FindClass(env, "java/lang/String");
+    if(classString)
+    {
+	    String_getBytes_ID = 
+		(*env)->GetMethodID(env, classString, "getBytes", "()[B");
+	    if(!String_getBytes_ID) return 0;
+	    String_init_ID = (*env)->GetMethodID(env, classString, "<init>", "([B)V");
+	    if(!String_init_ID) return 0;
+    } else return 0;
+    return 1;
+}
+
+/* Throw an exception by name */
+void LIBAPIENTRY jnitoolsThrowByName(JNIEnv *env, const char *name, const char *msg, ...)
+{
+    static char buffer[1024];
+    va_list va;
+    jclass cls = 0;
+
+    if(!isinit && init(env)) isinit=1;
+
+    va_start(va, msg);  
+
+    #ifdef NO_VSNPRINTF
+	    (void) vsprintf(buffer, msg, va); /* dangerous -> stack overwrite ... */
+    #else
+	    (void) vsnprintf(buffer, 1023, msg, va);
+    #endif
+    buffer[1023]=0;
+
+    va_end(va);
+
+    cls = (*env)->FindClass(env, name);
+
+    if (cls != 0) /* Otherwise an exception has already been thrown */
+        (*env)->ThrowNew(env, cls, buffer);
+
+    /* It's a good practice to clean up the local references. */
+    (*env)->DeleteLocalRef(env, cls);
+}
+
+/* Translates a Java string to a C string using the String.getBytes
+ * method, which uses default local encoding.
+ */
+char * LIBAPIENTRY jnitoolsGetJavaString(JNIEnv *env, jstring jstr)
+{
+    jbyteArray hab = 0;
+    jthrowable exc;
+    char *result = 0;
+
+    if(!isinit && init(env)) isinit=1;
+
+    hab = (*env)->CallObjectMethod(env, jstr, String_getBytes_ID);
+    exc = (*env)->ExceptionOccurred(env);
+    if (!exc) {
+        jint len = (*env)->GetArrayLength(env, hab);
+        result = (char *)malloc(len + 1);
+        if (result == 0) {
+            jnitoolsThrowByName(env, "java/lang/OutOfMemoryError", 0);
+            (*env)->DeleteLocalRef(env, hab);
+            return 0;
+        }
+        (*env)->GetByteArrayRegion(env, hab, 0, len, (jbyte *)result);
+        result[len] = 0; /* NULL-terminate */
+    } else {
+        (*env)->DeleteLocalRef(env, exc);
+    }
+    (*env)->DeleteLocalRef(env, hab);
+    return result;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+static JavaBasicType _jnitoolsGetJavaBasicTypeAndArgLen(JNIEnv *env, 
+                                                   const char * signature, int argIndex, 
+						   const char * errText,
+						   int * argLen)
+{
+	int i, j, arg, argend, arraydim;
+	char c, *help;
+	JavaBasicType jbt = T_NOPE;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	*argLen=0;
+
+	if(signature==NULL) return T_NOPE;
+	j=strlen(signature);
+
+	for(i=0, arg=0, argend=0, arraydim=0; i<j; i++)
+	{
+		c=signature[i];
+		if(c=='(') continue;
+		if(c==')') { argend=1; continue; }
+		if(c=='[') { arraydim++; continue; }
+		switch (c)
+		{
+			case 'L':
+				help = strchr(signature+i, ';');
+				if(help==NULL)
+				{
+				  jnitoolsThrowByName(env, 
+				        "java/lang/IllegalArgumentException",
+				        "%s(arg #%d): invalid signature (inv. object) at %d <%s>\n", 
+					 errText, argIndex+1, i, signature);
+				  return T_NOPE;
+				}
+				jbt = (arraydim==0)?T_OBJECT:T_OBJECT_ARRAY;
+				i = help-signature;
+				arraydim=0;
+				break;
+			case 'V':
+				if(arraydim>0)
+				{
+				  jnitoolsThrowByName(env, 
+				        "java/lang/IllegalArgumentException",
+				        "%s(arg #%d): invalid signature (void array) at %d <%s>\n", 
+					 errText, argIndex+1, i, signature);
+				  return T_NOPE;
+				}
+				jbt = T_VOID;
+				arraydim=0;
+				break;
+			case 'Z':
+				jbt = (arraydim==0)?T_BOOLEAN:T_BOOLEAN_ARRAY;
+				arraydim=0;
+				break;
+			case 'B':
+				jbt = (arraydim==0)?T_BYTE:T_BYTE_ARRAY;
+				arraydim=0;
+				break;
+			case 'C':
+				jbt = (arraydim==0)?T_CHAR:T_CHAR_ARRAY;
+				arraydim=0;
+				break;
+			case 'S':
+				jbt = (arraydim==0)?T_SHORT:T_SHORT_ARRAY;
+				arraydim=0;
+				break;
+			case 'I':
+				jbt = (arraydim==0)?T_INT:T_INT_ARRAY;
+				arraydim=0;
+				break;
+			case 'J':
+				jbt = (arraydim==0)?T_LONG:T_LONG_ARRAY;
+				arraydim=0;
+				break;
+			case 'F':
+				jbt = (arraydim==0)?T_FLOAT:T_FLOAT_ARRAY;
+				arraydim=0;
+				break;
+			case 'D':
+				jbt = (arraydim==0)?T_DOUBLE:T_DOUBLE_ARRAY;
+				arraydim=0;
+				break;
+		}
+		if( (argIndex >=0 && arg==argIndex) ||
+		    (argIndex==-1 && argend==1)
+		  )
+		{
+		  *argLen=arg;
+		  return jbt;
+		}
+		arg++;
+	}
+	return T_NOPE;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+int LIBAPIENTRY jnitoolsGetArgNumber(JNIEnv *env, 
+                                     const char * signature,
+				     const char * errText)
+{
+	int num = 0;
+	(void)  _jnitoolsGetJavaBasicTypeAndArgLen(env, 
+                                                   signature, -1,
+						   errText,
+						   &num);
+	return num;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+JavaBasicType LIBAPIENTRY jnitoolsGetJavaBasicType(JNIEnv *env, 
+                                                   const char * signature, int argIndex, 
+						   const char * errText)
+{
+	int num = 0;
+	JavaBasicType jbt = _jnitoolsGetJavaBasicTypeAndArgLen(env, 
+                                                   signature, argIndex,
+						   errText,
+						   &num);
+	return jbt;
+}
+
+jarray LIBAPIENTRY jnitoolsNativeArray2JavaArray (JNIEnv *env, JavaBasicType jbt, 
+                                     void *data, int dataArrayLen, 
+				     const char * errText, int arg)
+{
+	jarray res = 0;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			res = (*env)->NewBooleanArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetBooleanArrayRegion(env, (jbooleanArray)res, 
+							   0, dataArrayLen, 
+							   (jboolean*)data);
+			break;
+		case T_BYTE_ARRAY:
+			res = (*env)->NewByteArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetByteArrayRegion(env, (jbyteArray)res, 
+						   0, dataArrayLen, (jbyte*)data);
+			break;
+		case T_CHAR_ARRAY:
+			res = (*env)->NewCharArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetCharArrayRegion(env, (jcharArray)res, 
+						   0, dataArrayLen, (jchar*)data);
+			break;
+		case T_SHORT_ARRAY:
+			res = (*env)->NewShortArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetShortArrayRegion(env, (jshortArray)res, 
+						   0, dataArrayLen, (jshort*)data);
+			break;
+		case T_INT_ARRAY:
+			res = (*env)->NewIntArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetIntArrayRegion(env, (jintArray)res, 
+						   0, dataArrayLen, (jint*)data);
+			break;
+		case T_LONG_ARRAY:
+			res = (*env)->NewLongArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetLongArrayRegion(env, (jlongArray)res, 
+						   0, dataArrayLen, (jlong*)data);
+			break;
+		case T_FLOAT_ARRAY:
+			res = (*env)->NewFloatArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetFloatArrayRegion(env, (jfloatArray)res, 
+						   0, dataArrayLen, (jfloat*)data);
+			break;
+		case T_DOUBLE_ARRAY:
+			res = (*env)->NewDoubleArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetDoubleArrayRegion(env, (jdoubleArray)res, 
+						   0, dataArrayLen, (jdouble*)data);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+			return 0;
+	}
+	return res;
+}
+
+jarray LIBAPIENTRY jnitoolsNativePtrArray2JavaArray (JNIEnv *env, 
+						 JavaBasicType jbt, 
+                                                 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText, int arg)
+
+{
+	unsigned char * buffer = NULL;
+	jarray res = 0;
+	int i;
+	int setLenElems = dataArrayLen/pointerNumber;
+	int setLenBytes = 0;
+
+
+    	if(!isinit && init(env)) isinit=1;
+
+	switch(jbt)
+	{
+		case T_BYTE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jbyte) ;
+			break;
+		case T_CHAR_ARRAY:
+			setLenBytes = setLenElems * sizeof(jchar) ;
+			break;
+		case T_SHORT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jshort) ;
+			break;
+		case T_BOOLEAN_ARRAY:
+			setLenBytes = setLenElems * sizeof(jboolean) ;
+			break;
+		case T_INT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jint) ;
+			break;
+		case T_LONG_ARRAY:
+			setLenBytes = setLenElems * sizeof(jlong) ;
+			break;
+		case T_FLOAT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jfloat) ;
+			break;
+		case T_DOUBLE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jdouble) ;
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+			return 0;
+	}
+	buffer = calloc (pointerNumber, setLenBytes);
+	if(buffer==NULL)
+	{
+			jnitoolsThrowByName(env, "java/lang/Exception",
+				                "%s(arg #%d): Out of memory",
+						errText, arg);
+			return 0;
+	}
+	for(i=0; i<pointerNumber; i++)
+		memcpy(buffer+i*setLenBytes,
+		       data[i], setLenBytes);
+
+	res = jnitoolsNativeArray2JavaArray (env, jbt, 
+                                             buffer, dataArrayLen, 
+					     errText, arg);
+	free(buffer);
+	return res;
+}
+
+void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArray (JNIEnv *env, jarray arr, JavaBasicType jbt, 
+                                          void *data, int dataArrayLen, 
+					  const char * errText, int arg)
+{
+	int len = (*env)->GetArrayLength(env, arr);
+	int lenb = 0;
+	void * arrdata = 0;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	if(len!=dataArrayLen)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+					"%s(arg #%d): Array-Length differs of Java-Callback input(%d) vs output(%d)", errText, arg, dataArrayLen, len);
+		return;
+	}
+
+	arrdata = (void *) (*env)->GetPrimitiveArrayCritical(env, arr, 0);
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			lenb = len*sizeof(jboolean);
+			break;
+		case T_BYTE_ARRAY:
+			lenb = len*sizeof(jbyte);
+			break;
+		case T_CHAR_ARRAY:
+			lenb = len*sizeof(jchar);
+			break;
+		case T_SHORT_ARRAY:
+			lenb = len*sizeof(jshort);
+			break;
+		case T_INT_ARRAY:
+			lenb = len*sizeof(jint);
+			break;
+		case T_LONG_ARRAY:
+			lenb = len*sizeof(jlong);
+			break;
+		case T_FLOAT_ARRAY:
+			lenb = len*sizeof(jfloat);
+			break;
+		case T_DOUBLE_ARRAY:
+			lenb = len*sizeof(jdouble);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+	}
+	memcpy (data, arrdata, lenb);
+	(*env)->ReleasePrimitiveArrayCritical(env,  arr, arrdata, JNI_ABORT);
+}
+
+void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArrayPtr (JNIEnv *env, 
+				                 jarray arr, 
+						 JavaBasicType jbt, 
+                                                 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText,
+						 int arg)
+{
+	int len = (*env)->GetArrayLength(env, arr);
+	unsigned char * arrdata = 0;
+	int i;
+	int setLenElems = dataArrayLen/pointerNumber;
+	int setLenBytes = 0;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	if(len!=dataArrayLen)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+					"%s(arg #%d): Array-Length differs of Java-Callback input(%d) vs output(%d)", errText, arg, dataArrayLen, len);
+		return;
+	}
+
+	arrdata = (unsigned char *) 
+		(*env)->GetPrimitiveArrayCritical(env, arr, 0);
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			setLenBytes = setLenElems * sizeof(jboolean);
+			break;
+		case T_BYTE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jbyte);
+			break;
+		case T_CHAR_ARRAY:
+			setLenBytes = setLenElems * sizeof(jchar);
+			break;
+		case T_SHORT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jshort);
+			break;
+		case T_INT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jint);
+			break;
+		case T_LONG_ARRAY:
+			setLenBytes = setLenElems * sizeof(jlong);
+			break;
+		case T_FLOAT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jfloat);
+			break;
+		case T_DOUBLE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jdouble);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array", errText, arg);
+	}
+	for(i=0; i<pointerNumber; i++)
+		memcpy(data[i], arrdata+i*setLenBytes,
+		       setLenBytes);
+	(*env)->ReleasePrimitiveArrayCritical(env,  arr, arrdata, JNI_ABORT);
+}
+
+
+void * LIBAPIENTRY jnitoolsCreateNativeArray (JavaBasicType jbt, int dataArrayLen, const char * errText)
+{
+	void * arrdata = 0;
+
+	(void)errText;
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(int));
+			break;
+		case T_BYTE_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(char));
+			break;
+		case T_CHAR_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(char));
+			break;
+		case T_SHORT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(short));
+			break;
+		case T_INT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(int));
+			break;
+		case T_LONG_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(long));
+			break;
+		case T_FLOAT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(float));
+			break;
+		case T_DOUBLE_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(double));
+			break;
+		default:
+			return 0;
+	}
+	return arrdata;
+}
+
diff --git a/CNativeCode/jnitools.c b/CNativeCode/jnitools.c
new file mode 100644
index 0000000..18a4aa5
--- /dev/null
+++ b/CNativeCode/jnitools.c
@@ -0,0 +1,560 @@
+#include <string.h>
+#include "jnitools.h"
+
+#ifdef __BUILTIN_VA_ARG_INCR
+        /* Special stuff for the SunOS port ... */
+        va_list __builtin_va_arg_incr = 0;
+        va_list __builtin_va_alist = 0;
+#endif
+
+static int isinit = 0;
+static jclass classString=0;
+static jmethodID String_getBytes_ID=0;
+static jmethodID String_init_ID=0;
+
+static int init(JNIEnv *env)
+{
+    classString = (*env)->FindClass(env, "java/lang/String");
+    if(classString)
+    {
+	    String_getBytes_ID = 
+		(*env)->GetMethodID(env, classString, "getBytes", "()[B");
+	    if(!String_getBytes_ID) return 0;
+	    String_init_ID = (*env)->GetMethodID(env, classString, "<init>", "([B)V");
+	    if(!String_init_ID) return 0;
+    } else return 0;
+    return 1;
+}
+
+/* Throw an exception by name */
+void LIBAPIENTRY jnitoolsThrowByName(JNIEnv *env, const char *name, const char *msg, ...)
+{
+    static char buffer[1024];
+    va_list va;
+    jclass cls = 0;
+
+    if(!isinit && init(env)) isinit=1;
+
+    va_start(va, msg);  
+
+    #ifdef NO_VSNPRINTF
+	    (void) vsprintf(buffer, msg, va); /* dangerous -> stack overwrite ... */
+    #else
+	    (void) vsnprintf(buffer, 1023, msg, va);
+    #endif
+    buffer[1023]=0;
+
+    va_end(va);
+
+    cls = (*env)->FindClass(env, name);
+
+    if (cls != 0) /* Otherwise an exception has already been thrown */
+        (*env)->ThrowNew(env, cls, buffer);
+
+    /* It's a good practice to clean up the local references. */
+    (*env)->DeleteLocalRef(env, cls);
+}
+
+/* Translates a Java string to a C string using the String.getBytes
+ * method, which uses default local encoding.
+ */
+char * LIBAPIENTRY jnitoolsGetJavaString(JNIEnv *env, jstring jstr)
+{
+    jbyteArray hab = 0;
+    jthrowable exc;
+    char *result = 0;
+
+    if(!isinit && init(env)) isinit=1;
+
+    hab = (*env)->CallObjectMethod(env, jstr, String_getBytes_ID);
+    exc = (*env)->ExceptionOccurred(env);
+    if (!exc) {
+        jint len = (*env)->GetArrayLength(env, hab);
+        result = (char *)malloc(len + 1);
+        if (result == 0) {
+            jnitoolsThrowByName(env, "java/lang/OutOfMemoryError", 0);
+            (*env)->DeleteLocalRef(env, hab);
+            return 0;
+        }
+        (*env)->GetByteArrayRegion(env, hab, 0, len, (jbyte *)result);
+        result[len] = 0; /* NULL-terminate */
+    } else {
+        (*env)->DeleteLocalRef(env, exc);
+    }
+    (*env)->DeleteLocalRef(env, hab);
+    return result;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+static JavaBasicType _jnitoolsGetJavaBasicTypeAndArgLen(JNIEnv *env, 
+                                                   const char * signature, int argIndex, 
+						   const char * errText,
+						   int * argLen)
+{
+	int i, j, arg, argend, arraydim;
+	char c, *help;
+	JavaBasicType jbt = T_NOPE;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	*argLen=0;
+
+	if(signature==NULL) return T_NOPE;
+	j=strlen(signature);
+
+	for(i=0, arg=0, argend=0, arraydim=0; i<j; i++)
+	{
+		c=signature[i];
+		if(c=='(') continue;
+		if(c==')') { argend=1; continue; }
+		if(c=='[') { arraydim++; continue; }
+		switch (c)
+		{
+			case 'L':
+				help = strchr(signature+i, ';');
+				if(help==NULL)
+				{
+				  jnitoolsThrowByName(env, 
+				        "java/lang/IllegalArgumentException",
+				        "%s(arg #%d): invalid signature (inv. object) at %d <%s>\n", 
+					 errText, argIndex+1, i, signature);
+				  return T_NOPE;
+				}
+				jbt = (arraydim==0)?T_OBJECT:T_OBJECT_ARRAY;
+				i = help-signature;
+				arraydim=0;
+				break;
+			case 'V':
+				if(arraydim>0)
+				{
+				  jnitoolsThrowByName(env, 
+				        "java/lang/IllegalArgumentException",
+				        "%s(arg #%d): invalid signature (void array) at %d <%s>\n", 
+					 errText, argIndex+1, i, signature);
+				  return T_NOPE;
+				}
+				jbt = T_VOID;
+				arraydim=0;
+				break;
+			case 'Z':
+				jbt = (arraydim==0)?T_BOOLEAN:T_BOOLEAN_ARRAY;
+				arraydim=0;
+				break;
+			case 'B':
+				jbt = (arraydim==0)?T_BYTE:T_BYTE_ARRAY;
+				arraydim=0;
+				break;
+			case 'C':
+				jbt = (arraydim==0)?T_CHAR:T_CHAR_ARRAY;
+				arraydim=0;
+				break;
+			case 'S':
+				jbt = (arraydim==0)?T_SHORT:T_SHORT_ARRAY;
+				arraydim=0;
+				break;
+			case 'I':
+				jbt = (arraydim==0)?T_INT:T_INT_ARRAY;
+				arraydim=0;
+				break;
+			case 'J':
+				jbt = (arraydim==0)?T_LONG:T_LONG_ARRAY;
+				arraydim=0;
+				break;
+			case 'F':
+				jbt = (arraydim==0)?T_FLOAT:T_FLOAT_ARRAY;
+				arraydim=0;
+				break;
+			case 'D':
+				jbt = (arraydim==0)?T_DOUBLE:T_DOUBLE_ARRAY;
+				arraydim=0;
+				break;
+		}
+		if( (argIndex >=0 && arg==argIndex) ||
+		    (argIndex==-1 && argend==1)
+		  )
+		{
+		  *argLen=arg;
+		  return jbt;
+		}
+		arg++;
+	}
+	return T_NOPE;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+int LIBAPIENTRY jnitoolsGetArgNumber(JNIEnv *env, 
+                                     const char * signature,
+				     const char * errText)
+{
+	int num = 0;
+	(void)  _jnitoolsGetJavaBasicTypeAndArgLen(env, 
+                                                   signature, -1,
+						   errText,
+						   &num);
+	return num;
+}
+
+/**
+ * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+ *
+ * argIndex:  0-n argument index of the method signature
+ *            -1  return type
+ */
+JavaBasicType LIBAPIENTRY jnitoolsGetJavaBasicType(JNIEnv *env, 
+                                                   const char * signature, int argIndex, 
+						   const char * errText)
+{
+	int num = 0;
+	JavaBasicType jbt = _jnitoolsGetJavaBasicTypeAndArgLen(env, 
+                                                   signature, argIndex,
+						   errText,
+						   &num);
+	return jbt;
+}
+
+jarray LIBAPIENTRY jnitoolsNativeArray2JavaArray (JNIEnv *env, JavaBasicType jbt, 
+                                     void *data, int dataArrayLen, 
+				     const char * errText, int arg)
+{
+	jarray res = 0;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			res = (*env)->NewBooleanArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetBooleanArrayRegion(env, (jbooleanArray)res, 
+							   0, dataArrayLen, 
+							   (jboolean*)data);
+			break;
+		case T_BYTE_ARRAY:
+			res = (*env)->NewByteArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetByteArrayRegion(env, (jbyteArray)res, 
+						   0, dataArrayLen, (jbyte*)data);
+			break;
+		case T_CHAR_ARRAY:
+			res = (*env)->NewCharArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetCharArrayRegion(env, (jcharArray)res, 
+						   0, dataArrayLen, (jchar*)data);
+			break;
+		case T_SHORT_ARRAY:
+			res = (*env)->NewShortArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetShortArrayRegion(env, (jshortArray)res, 
+						   0, dataArrayLen, (jshort*)data);
+			break;
+		case T_INT_ARRAY:
+			res = (*env)->NewIntArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetIntArrayRegion(env, (jintArray)res, 
+						   0, dataArrayLen, (jint*)data);
+			break;
+		case T_LONG_ARRAY:
+			res = (*env)->NewLongArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetLongArrayRegion(env, (jlongArray)res, 
+						   0, dataArrayLen, (jlong*)data);
+			break;
+		case T_FLOAT_ARRAY:
+			res = (*env)->NewFloatArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetFloatArrayRegion(env, (jfloatArray)res, 
+						   0, dataArrayLen, (jfloat*)data);
+			break;
+		case T_DOUBLE_ARRAY:
+			res = (*env)->NewDoubleArray(env, dataArrayLen);
+			if(data!=NULL)
+				(*env)->SetDoubleArrayRegion(env, (jdoubleArray)res, 
+						   0, dataArrayLen, (jdouble*)data);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+			return 0;
+	}
+	return res;
+}
+
+jarray LIBAPIENTRY jnitoolsNativePtrArray2JavaArray (JNIEnv *env, 
+						 JavaBasicType jbt, 
+                                                 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText, int arg)
+
+{
+	unsigned char * buffer = NULL;
+	jarray res = 0;
+	int i;
+	int setLenElems = dataArrayLen/pointerNumber;
+	int setLenBytes = 0;
+
+
+    	if(!isinit && init(env)) isinit=1;
+
+	switch(jbt)
+	{
+		case T_BYTE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jbyte) ;
+			break;
+		case T_CHAR_ARRAY:
+			setLenBytes = setLenElems * sizeof(jchar) ;
+			break;
+		case T_SHORT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jshort) ;
+			break;
+		case T_BOOLEAN_ARRAY:
+			setLenBytes = setLenElems * sizeof(jboolean) ;
+			break;
+		case T_INT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jint) ;
+			break;
+		case T_LONG_ARRAY:
+			setLenBytes = setLenElems * sizeof(jlong) ;
+			break;
+		case T_FLOAT_ARRAY:
+			setLenBytes = setLenElems * sizeof(jfloat) ;
+			break;
+		case T_DOUBLE_ARRAY:
+			setLenBytes = setLenElems * sizeof(jdouble) ;
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+			return 0;
+	}
+	buffer = calloc (pointerNumber, setLenBytes);
+	if(buffer==NULL)
+	{
+			jnitoolsThrowByName(env, "java/lang/Exception",
+				                "%s(arg #%d): Out of memory",
+						errText, arg);
+			return 0;
+	}
+	for(i=0; i<pointerNumber; i++)
+		memcpy(buffer+i*setLenBytes,
+		       data[i], setLenBytes);
+
+	res = jnitoolsNativeArray2JavaArray (env, jbt, 
+                                             buffer, dataArrayLen, 
+					     errText, arg);
+	free(buffer);
+	return res;
+}
+
+void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArray (JNIEnv *env, jarray arr, JavaBasicType jbt, 
+                                          void *data, int dataArrayLen, 
+					  const char * errText, int arg)
+{
+	int len = (*env)->GetArrayLength(env, arr);
+	void * arrdata = 0;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	if(len!=dataArrayLen)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+					"%s(arg #%d): Array-Length differs of Java-Callback input(%d) vs output(%d)", errText, arg, dataArrayLen, len);
+		return;
+	}
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			arrdata = (*env)->GetBooleanArrayElements(env, (jbooleanArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jboolean));
+			(*env)->ReleaseBooleanArrayElements(env,(jbooleanArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_BYTE_ARRAY:
+			arrdata = (*env)->GetByteArrayElements(env, (jbyteArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jbyte));
+			(*env)->ReleaseByteArrayElements(env,(jbyteArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_CHAR_ARRAY:
+			arrdata = (*env)->GetCharArrayElements(env, (jcharArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jchar));
+			(*env)->ReleaseCharArrayElements(env,(jcharArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_SHORT_ARRAY:
+			arrdata = (*env)->GetShortArrayElements(env, (jshortArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jshort));
+			(*env)->ReleaseShortArrayElements(env,(jshortArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_INT_ARRAY:
+			arrdata = (*env)->GetIntArrayElements(env, (jintArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jint));
+			(*env)->ReleaseIntArrayElements(env,(jintArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_LONG_ARRAY:
+			arrdata = (*env)->GetLongArrayElements(env, (jlongArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jlong));
+			(*env)->ReleaseLongArrayElements(env,(jlongArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_FLOAT_ARRAY:
+			arrdata = (*env)->GetFloatArrayElements(env, (jfloatArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jfloat));
+			(*env)->ReleaseFloatArrayElements(env,(jfloatArray)arr,arrdata,JNI_ABORT);
+			break;
+		case T_DOUBLE_ARRAY:
+			arrdata = (*env)->GetDoubleArrayElements(env, (jdoubleArray)arr, 0);
+			memcpy (data, arrdata, len*sizeof(jdouble));
+			(*env)->ReleaseDoubleArrayElements(env,(jdoubleArray)arr,arrdata,JNI_ABORT);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array",
+						errText, arg);
+	}
+}
+
+void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArrayPtr (JNIEnv *env, 
+				                 jarray arr, 
+						 JavaBasicType jbt, 
+                                                 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText,
+						 int arg)
+{
+	int len = (*env)->GetArrayLength(env, arr);
+	unsigned char * arrdata = 0;
+	int i;
+	int setLenElems = dataArrayLen/pointerNumber;
+	int setLenBytes;
+
+    	if(!isinit && init(env)) isinit=1;
+
+	if(len!=dataArrayLen)
+	{
+		jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+					"%s(arg #%d): Array-Length differs of Java-Callback input(%d) vs output(%d)", errText, arg, dataArrayLen, len);
+		return;
+	}
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetBooleanArrayElements(env, (jbooleanArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jboolean);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseBooleanArrayElements(env,(jbooleanArray)arr, (jboolean *)arrdata,JNI_ABORT);
+			break;
+		case T_BYTE_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetByteArrayElements(env, (jbyteArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jbyte);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseByteArrayElements(env,(jbyteArray)arr, (jbyte *)arrdata,JNI_ABORT);
+			break;
+		case T_CHAR_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetCharArrayElements(env, (jcharArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jchar);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseCharArrayElements(env,(jcharArray)arr, (jchar *)arrdata,JNI_ABORT);
+			break;
+		case T_SHORT_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetShortArrayElements(env, (jshortArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jshort);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseShortArrayElements(env,(jshortArray)arr, (jshort *)arrdata,JNI_ABORT);
+			break;
+		case T_INT_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetIntArrayElements(env, (jintArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jint);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseIntArrayElements(env,(jintArray)arr, (jint *)arrdata,JNI_ABORT);
+			break;
+		case T_LONG_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetLongArrayElements(env, (jlongArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jlong);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseLongArrayElements(env,(jlongArray)arr, (jlong *)arrdata,JNI_ABORT);
+			break;
+		case T_FLOAT_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetFloatArrayElements(env, (jfloatArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jfloat);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseFloatArrayElements(env,(jfloatArray)arr, (jfloat *)arrdata,JNI_ABORT);
+			break;
+		case T_DOUBLE_ARRAY:
+			arrdata = (unsigned char *) (*env)->GetDoubleArrayElements(env, (jdoubleArray)arr, 0);
+			setLenBytes = setLenElems * sizeof(jdouble);
+			for(i=0; i<pointerNumber; i++)
+				memcpy(data[i], arrdata+i*setLenBytes,
+				       setLenBytes);
+			(*env)->ReleaseDoubleArrayElements(env,(jdoubleArray)arr, (jdouble *)arrdata,JNI_ABORT);
+			break;
+		default:
+			jnitoolsThrowByName(env, "java/lang/IllegalArgumentException",
+				                "%s(arg #%d): Type is not an array", errText, arg);
+	}
+}
+
+
+void * LIBAPIENTRY jnitoolsCreateNativeArray (JavaBasicType jbt, int dataArrayLen, const char * errText)
+{
+	void * arrdata = 0;
+
+	(void)errText;
+
+	switch(jbt)
+	{
+		case T_BOOLEAN_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(int));
+			break;
+		case T_BYTE_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(char));
+			break;
+		case T_CHAR_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(char));
+			break;
+		case T_SHORT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(short));
+			break;
+		case T_INT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(int));
+			break;
+		case T_LONG_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(long));
+			break;
+		case T_FLOAT_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(float));
+			break;
+		case T_DOUBLE_ARRAY:
+			arrdata = calloc(dataArrayLen, sizeof(double));
+			break;
+		default:
+			return 0;
+	}
+	return arrdata;
+}
+
diff --git a/CNativeCode/jnitools.h b/CNativeCode/jnitools.h
new file mode 100644
index 0000000..ee02405
--- /dev/null
+++ b/CNativeCode/jnitools.h
@@ -0,0 +1,122 @@
+
+#ifndef JNITOOLS
+	#define JNITOOLS
+
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <stdarg.h>
+
+	#ifdef _WIN32_
+		#include "winstuff.h"
+	#endif
+
+	#include <jni.h>
+
+	#ifndef LIBAPIENTRY
+		#define LIBAPIENTRY
+	#endif
+	#ifndef LIBAPI
+		#define LIBAPI
+	#endif
+
+	typedef enum {
+		T_NOPE = 0,
+		T_VOID,
+		T_BOOLEAN,
+		T_BYTE,
+		T_CHAR,
+		T_SHORT,
+		T_INT,
+		T_LONG,
+		T_FLOAT,
+		T_DOUBLE,
+		T_OBJECT,
+		T_ARRAY_TYPE_BORDER,
+		T_BOOLEAN_ARRAY,
+		T_BYTE_ARRAY,
+		T_CHAR_ARRAY,
+		T_SHORT_ARRAY,
+		T_INT_ARRAY,
+		T_LONG_ARRAY,
+		T_FLOAT_ARRAY,
+		T_DOUBLE_ARRAY,
+		T_OBJECT_ARRAY
+	} JavaBasicType;
+
+	/* Throw an exception by name */
+	LIBAPI void LIBAPIENTRY jnitoolsThrowByName(JNIEnv *env, const char *name, const char *msg, ...);
+
+	/* Translates a Java string to a C string using the String.getBytes
+	 * method, which uses default local encoding.
+	 */
+	LIBAPI char * LIBAPIENTRY jnitoolsGetJavaString(JNIEnv *env, jstring jstr);
+
+	/**
+	 * signature: e.g. "(II[I)V" for "void <name>(int, int, int[])"
+	 *
+	 * argIndex:  0-n argument index of the method signature
+	 *            -1  return type
+	 */
+	LIBAPI JavaBasicType LIBAPIENTRY jnitoolsGetJavaBasicType(JNIEnv *env, const char * signature, int argIndex, const char * errText);
+
+	LIBAPI int LIBAPIENTRY jnitoolsGetArgNumber(JNIEnv *env, 
+					     const char * signature,
+					     const char * errText);
+	/**
+	 * e.g.: int a[4];
+	 *       jarray arr = jnitoolsNativeArray2JavaArray(env, T_INT_ARRAY,
+	 *	 				            a, 4);
+	 */
+	LIBAPI jarray LIBAPIENTRY jnitoolsNativeArray2JavaArray (JNIEnv *env, 
+					     JavaBasicType jbt, 
+					     void *data, int dataArrayLen, 
+					     const char * errText, int arg);
+
+	/**
+	 * e.g.: int * a[2];
+	 *       a[0] = calloc (4, sizeof(int));
+	 *       a[1] = calloc (4, sizeof(int));
+	 *       jarray arr = jnitoolsNativePtrArray2JavaArray(env, T_INT_ARRAY,
+	 *	 				            a, 2, 8);
+	 */
+	LIBAPI jarray LIBAPIENTRY jnitoolsNativePtrArray2JavaArray(JNIEnv *env, 
+						 JavaBasicType jbt, 
+                                                 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText, int arg);
+
+
+	/**
+	 * e.g.: int a[4];
+	 *       jarray arr = ...
+	 *       jnitoolsReleaseJavaArray2NativeArray(env, arr, T_INT_ARRAY,
+	 *	 				      a, 4);
+	 */
+	LIBAPI void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArray(
+						 JNIEnv *env, 
+						 jarray arr, JavaBasicType jbt, 
+						 void *data, int dataArrayLen, 
+						 const char * errText, int arg);
+
+	/**
+	 * e.g.: int * a[2];
+	 *       a[0] = calloc (4, sizeof(int));
+	 *       a[1] = calloc (4, sizeof(int));
+	 *       jarray arr = ...
+	 *       jnitoolsReleaseJavaArray2NativeArrayPtr (env, arr, T_INT_ARRAY,
+	 *	 				          a, 2, 8);
+	 */
+	LIBAPI void LIBAPIENTRY jnitoolsReleaseJavaArray2NativeArrayPtr (
+						 JNIEnv *env, 
+						 jarray arr, 
+						 JavaBasicType jbt, 
+						 void *data[/*pointerNumber*/], 
+						 int pointerNumber, 
+						 int dataArrayLen, 
+						 const char * errText, int arg);
+
+	LIBAPI void * LIBAPIENTRY jnitoolsCreateNativeArray (JavaBasicType jbt, 
+							    int dataArrayLen, 
+							    const char * errText);
+#endif
diff --git a/CNativeCode/mac_console.c b/CNativeCode/mac_console.c
new file mode 100644
index 0000000..669bba3
--- /dev/null
+++ b/CNativeCode/mac_console.c
@@ -0,0 +1,119 @@
+// File "mac_console.c"
+
+#include <stdio.h>
+#include "mac_console.h"
+
+
+static	JNIEnv	*gJNIenv			= nil;
+
+static	char	kMessage[]			= "";
+static	char	gMessage[BUFSIZ];
+
+
+//
+// InstallJavaConsole
+//
+void InstallJavaConsole(JNIEnv *env)
+{
+	gJNIenv = env;
+}
+
+//
+// UninstallJavaConsole
+//
+void UninstallJavaConsole(void)
+{
+	gJNIenv = nil;
+}
+
+
+//
+// InstallConsole
+//
+int InstallConsole(void)
+{
+}
+
+//
+// RemoveConsole
+//
+int RemoveConsole(void)
+{
+}
+
+//
+// WriteCharsToConsole
+//
+int WriteCharsToConsole(void)
+{
+	jclass		class_System;
+	jfieldID	id_err;
+	jobject		object_err;
+	jclass		class_PrintStream;
+	jmethodID	id_println;
+	jmethodID	id_flush;
+	jstring		string			= nil;
+	int			messageLength	= 0;
+	char		*message		= nil;
+	
+	
+	// _FILE
+	//debugstr((char*)stderr->buffer);
+	
+	if (gJNIenv != nil)
+	{
+		if (stderr->buffer_len > 0)
+		{
+			messageLength = stderr->buffer_len;
+			message = (char*)stderr->buffer;
+		}
+		else if (stdout->buffer_len > 0)
+		{
+			messageLength = stdout->buffer_len;
+			message = (char*)stdout->buffer;
+		}
+		
+		if (messageLength < BUFSIZ)
+		{
+			strncpy(gMessage, message, messageLength);
+			gMessage[messageLength] = '\0';
+		}
+		else
+		{
+			strncpy(gMessage, message, BUFSIZ);
+			gMessage[BUFSIZ-1] = '\0';
+		}
+		
+		string = (*gJNIenv)->NewStringUTF(gJNIenv, gMessage);
+		if (string != nil)
+		{
+			class_System		= (*gJNIenv)->FindClass(gJNIenv, "java/lang/System");
+			id_err				= (*gJNIenv)->GetStaticFieldID(gJNIenv, class_System, "err", "Ljava/io/PrintStream;");
+			object_err			= (*gJNIenv)->GetStaticObjectField(gJNIenv, class_System, id_err);
+			class_PrintStream	= (*gJNIenv)->GetObjectClass(gJNIenv, object_err);
+			id_println			= (*gJNIenv)->GetMethodID(gJNIenv, class_PrintStream, "print", "(Ljava/lang/String;)V");
+			
+			(*gJNIenv)->CallVoidMethod(gJNIenv, object_err, id_println, string);
+			
+	    	(*gJNIenv)->DeleteLocalRef(gJNIenv, string);
+	    	(*gJNIenv)->DeleteLocalRef(gJNIenv, class_PrintStream);
+	    	(*gJNIenv)->DeleteLocalRef(gJNIenv, object_err);
+	    	(*gJNIenv)->DeleteLocalRef(gJNIenv, class_System);
+	    }
+	    else
+	    {
+			//debugstr("string is null");
+	    }
+	}
+	else
+	{
+		//debugstr("gJNIenv is null");
+	}
+}
+
+//
+// ReadCharsFromConsole
+//
+int ReadCharsFromConsole(void)
+{
+}
diff --git a/CNativeCode/mac_console.h b/CNativeCode/mac_console.h
new file mode 100644
index 0000000..59ba834
--- /dev/null
+++ b/CNativeCode/mac_console.h
@@ -0,0 +1,16 @@
+// File "mac_console.h"
+
+#include <jni.h>
+#include <stdio.h>
+#include <string.h>
+#include <MacTypes.h>
+#include <MacMemory.h>
+
+
+void InstallJavaConsole(JNIEnv *env);
+void UninstallJavaConsole(void);
+int InstallConsole(void);
+int RemoveConsole(void);
+int WriteCharsToConsole(void);
+int ReadCharsFromConsole(void);
+
diff --git a/CNativeCode/mac_nop_main.c b/CNativeCode/mac_nop_main.c
new file mode 100644
index 0000000..011711a
--- /dev/null
+++ b/CNativeCode/mac_nop_main.c
@@ -0,0 +1 @@
+#include <stdio.h>

int main()
{
	printf("GL4Java-Main NOP called (DLL)!");
	return 0;
}

\ No newline at end of file
diff --git a/CNativeCode/macppcdefs.h b/CNativeCode/macppcdefs.h
new file mode 100644
index 0000000..b1aa588
--- /dev/null
+++ b/CNativeCode/macppcdefs.h
@@ -0,0 +1,7 @@
+#ifndef _macppcdefs_h
+	#define _macppcdefs_h
+
+	#define __LIB_VERSION__ "2.4.1.2"
+
+	#define NDEBUG
+#endif
diff --git a/CNativeCode/makeFuncs b/CNativeCode/makeFuncs
new file mode 100755
index 0000000..48208cc
--- /dev/null
+++ b/CNativeCode/makeFuncs
@@ -0,0 +1,4 @@
+#! /bin/sh
+
+sed 's/;/{	fprintf(stderr,"function not implemented in SGI-Irix65-GL\n");}/g' a.h > a.c
+
diff --git a/CNativeCode/misc/context.h b/CNativeCode/misc/context.h
new file mode 100644
index 0000000..cee1d75
--- /dev/null
+++ b/CNativeCode/misc/context.h
@@ -0,0 +1,18 @@
+
+
+typedef struct GL4JCtxData {
+	int    handle;    // the java side - handle
+	void * glContext; // the orig. GL context
+	void * vertex;    // 
+	void * normal;
+	void * color;
+	void * index;
+	void * texcoords[];
+	void * edgeflag;
+};
+
+#define MAX_GL4J_CONTEXT = 100;
+extern GL4JCtxData gl4jCtxData[MAX_GL4J_CONTEXT];
+
+GL4JCtxData findGL4JCtxData(void * glcontext);
+void releaseGL4JCtxData(GL4JCtxData * data);
diff --git a/CNativeCode/misc/glx_pbuffers.txt b/CNativeCode/misc/glx_pbuffers.txt
new file mode 100644
index 0000000..126e339
--- /dev/null
+++ b/CNativeCode/misc/glx_pbuffers.txt
@@ -0,0 +1,80 @@
+   [Add the following to section 3.2.3 on Offscreen Rendering]
+
+    To create a GLXPbuffer call:
+
+        GLXPbuffer glXCreateGLXPbufferSGIX(Display *dpy,
+                                           GLXFBConfig config,
+                                           unsigned int width,
+                                           unsigned int height,
+                                           int *attrib_list);
+
+    This creates a single GLXPbuffer and returns its XID. <width> and <height>
+    specify the pixel width and height of the rectangular pbuffer and
+    <attrib_list> specifies a list of attributes for the pbuffer. Currently
+    only three attributes can be specified in <attrib_list>:
+    GLX_PRESERVED_CONTENTS_SGIX, GLX_LARGEST_PBUFFER_SGIX and
+    GLX_DIGITAL_MEDIA_PBUFFER_SGIX.
+
+    [Add following the section on the GLX_PRESERVED_CONTENTS_SGIX attrib]
+
+    The resulting pbuffer, when made current, will contain color buffers 
+    and ancillary buffers as specified by <config>. It is possible to create 
+    a pbuffer with back buffers and to swap the front and back buffers by 
+    calling glXSwapBuffers. Note that some pbuffers use framebuffer resources 
+    so applications should consider deallocating them when they are not in use.
+
+    If the GLX_DIGITAL_MEDIA_PBUFFER_SGIX attribute is set to True in
+    <attrib_list>, then one or more of the pbuffer's color or ancillary 
+    buffers may be shared with those of a currently associated DMbuffer.  
+    Buffers described by the pbuffer's GLXFBConfig which are not defined
+    by the DMbuffer, are GLX resources that remain associated with the
+    DM pbuffer until it is destroyed.
+    An implementation may fail glXCreateGLXPbufferSGIX and generate a
+    BadMatch error when the sepcified <config> does not describe a  
+    drawable that is compatible with any supported DMbuffers.
+
+    The GLXPbuffer is associated with a DMbuffer by calling:
+
+        Bool glXAssociateDMPbufferSGIX(Display *dpy,
+                                       GLXPbufferSGIX pbuffer,
+                                       DMparams *params,
+                                       DMbuffer dmbuffer);
+
+    The parameter <display> specifies a connection to an X server, and must 
+    match the display used to create the GLXPbuffer <pbuffer>.  The 
+    DMparams <params> arg specifies the digital media characteristics
+    of the <dmbuffer> that will be associated with the DM pbuffer.  
+    If glXAssociateDMbufferSGIX succeeds, any previously associated DMbuffer
+    is released and a value of True is returned.  Subsequent GL commands 
+    effect <dmbuffer> as they would any standard pbuffer.  If a newly 
+    released DMbuffer has no remaining clients, its buffers will also be freed. 
+    A BadMatch error is generated when the specified DMparams or DMbuffer
+    are not compatible with the <pbuffer>, and a value of False is returned.
+
+    Before the DM pbuffer can be made current to a GLXContext, it must 
+    be associated with a compatible DMbuffer.  glXMakeCurrentReadSGI will 
+    return False and generate a GLXBadDrawable error when a DM pbuffer 
+    drawable has no associated DMbuffer.
+
+    A GLXPbuffer is destroyed by calling:
+
+        void glXDestroyGLXPbufferSGIX(Display *dpy,
+                                      GLXPbuffer pbuf);
+
+    The GLXPbuffer will be destroyed once it is no longer current to any
+    client. When a GLXPbuffer is destroyed, any memory resources that
+    attached to it, are freed, and its XID is made available for reuse.
+    Associated DMbuffers are released, and if they no lonnger have a 
+    client, are also freed. 
+
+Errors
+
+    XXX - not complete yet
+
+New State
+
+    None.
+
+New Implementation Dependent State
+
+    None.
diff --git a/CNativeCode/winstuff.h.skel b/CNativeCode/winstuff.h.skel
new file mode 100644
index 0000000..1cfc688
--- /dev/null
+++ b/CNativeCode/winstuff.h.skel
@@ -0,0 +1,33 @@
+#ifndef __WINSTUFF__

+	#define __WINSTUFF__

+

+	#include <windows.h>

+

+	/**

+	 * Out of the Document:

+	 * 	http://java.sun.com/products/jdk/faq/jni-j2sdk-faq.html

+	 * So if you have trouble with the type __int64,

+	 * please use this #define !!!

+	 */

+	#ifdef FOOBAR_COMPILER

+          #define __int64 signed_64_bit_type

+        #endif

+

+	/*

+   	#include "gl.win32.not.h"

+	#include "gl.win32.ext.h"

+	*/

+

+   	#define __LIB_VERSION__ __SED_LIB_VERSION__

+

+	#ifdef LIBAPIENTRY

+		#undef LIBAPIENTRY

+	#endif

+	#ifdef LIBAPI

+		#undef LIBAPI

+	#endif

+

+	#define LIBAPI	        __declspec(dllexport)

+	#define LIBAPIENTRY    __stdcall

+#endif

+