////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////

package gles

import (
	"fmt"

	"android.googlesource.com/platform/tools/gpu/atom"
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/memory"
)

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*Architecture)(nil).Class())
	Namespace.Add((*BackbufferInfo)(nil).Class())
	Namespace.Add((*Color)(nil).Class())
	Namespace.Add((*BlendState)(nil).Class())
	Namespace.Add((*SliceInfo)(nil).Class())
	Namespace.Add((*U8ˢ)(nil).Class())
	Namespace.Add((*Buffer)(nil).Class())
	Namespace.Add((*BufferDataPointer)(nil).Class())
	Namespace.Add((*BufferIdˢ)(nil).Class())
	Namespace.Add((*BufferIdᵖ)(nil).Class())
	Namespace.Add((*BufferIdᶜᵖ)(nil).Class())
	Namespace.Add((*CGLContextObj)(nil).Class())
	Namespace.Add((*CGLContextObjˢ)(nil).Class())
	Namespace.Add((*CGLContextObjᵖ)(nil).Class())
	Namespace.Add((*CGLPixelFormatObj)(nil).Class())
	Namespace.Add((*CGLCreateContext)(nil).Class())
	Namespace.Add((*CGLFlushDrawable)(nil).Class())
	Namespace.Add((*CGSConnectionIDᵖ)(nil).Class())
	Namespace.Add((*CGSWindowIDᵖ)(nil).Class())
	Namespace.Add((*CGSSurfaceIDᵖ)(nil).Class())
	Namespace.Add((*CGLGetSurface)(nil).Class())
	Namespace.Add((*CGLSetCurrentContext)(nil).Class())
	Namespace.Add((*CGSConnectionID)(nil).Class())
	Namespace.Add((*CGSConnectionIDˢ)(nil).Class())
	Namespace.Add((*F64ᵖ)(nil).Class())
	Namespace.Add((*CGSGetSurfaceBounds)(nil).Class())
	Namespace.Add((*CGSSurfaceIDˢ)(nil).Class())
	Namespace.Add((*CGSWindowIDˢ)(nil).Class())
	Namespace.Add((*Charˢ)(nil).Class())
	Namespace.Add((*Charᵖ)(nil).Class())
	Namespace.Add((*ClearState)(nil).Class())
	Namespace.Add((*Rect)(nil).Class())
	Namespace.Add((*RasterizerState)(nil).Class())
	Namespace.Add((*VertexPointer)(nil).Class())
	Namespace.Add((*VertexAttributeArray)(nil).Class())
	Namespace.Add((*Renderbuffer)(nil).Class())
	Namespace.Add((*Image)(nil).Class())
	Namespace.Add((*CubemapLevel)(nil).Class())
	Namespace.Add((*Texture)(nil).Class())
	Namespace.Add((*FramebufferAttachmentInfo)(nil).Class())
	Namespace.Add((*Framebuffer)(nil).Class())
	Namespace.Add((*GLcharˢ)(nil).Class())
	Namespace.Add((*Shader)(nil).Class())
	Namespace.Add((*VertexAttribute)(nil).Class())
	Namespace.Add((*Uniform)(nil).Class())
	Namespace.Add((*Program)(nil).Class())
	Namespace.Add((*VertexArray)(nil).Class())
	Namespace.Add((*Query)(nil).Class())
	Namespace.Add((*Objects)(nil).Class())
	Namespace.Add((*Context)(nil).Class())
	Namespace.Add((*EGLConfig)(nil).Class())
	Namespace.Add((*EGLContext)(nil).Class())
	Namespace.Add((*EGLDisplay)(nil).Class())
	Namespace.Add((*EGLSurface)(nil).Class())
	Namespace.Add((*EGLintˢ)(nil).Class())
	Namespace.Add((*EGLintᵖ)(nil).Class())
	Namespace.Add((*EglCreateContext)(nil).Class())
	Namespace.Add((*EglInitialize)(nil).Class())
	Namespace.Add((*EglMakeCurrent)(nil).Class())
	Namespace.Add((*EglQuerySurface)(nil).Class())
	Namespace.Add((*Voidᵖ)(nil).Class())
	Namespace.Add((*EglSwapBuffers)(nil).Class())
	Namespace.Add((*F64ˢ)(nil).Class())
	Namespace.Add((*FlushPostBuffer)(nil).Class())
	Namespace.Add((*FramebufferIdˢ)(nil).Class())
	Namespace.Add((*FramebufferIdᵖ)(nil).Class())
	Namespace.Add((*FramebufferIdᶜᵖ)(nil).Class())
	Namespace.Add((*GLDEBUGPROCKHR)(nil).Class())
	Namespace.Add((*GLXContext)(nil).Class())
	Namespace.Add((*GLXDrawable)(nil).Class())
	Namespace.Add((*GLbooleanˢ)(nil).Class())
	Namespace.Add((*GLbooleanᵖ)(nil).Class())
	Namespace.Add((*GLcharᵖ)(nil).Class())
	Namespace.Add((*GLcharᶜᵖ)(nil).Class())
	Namespace.Add((*GLcharᶜᵖˢ)(nil).Class())
	Namespace.Add((*GLcharᶜᵖᵖ)(nil).Class())
	Namespace.Add((*GLcharᶜᵖᶜᵖ)(nil).Class())
	Namespace.Add((*GLeglImageOES)(nil).Class())
	Namespace.Add((*GLenumˢ)(nil).Class())
	Namespace.Add((*GLenumᵖ)(nil).Class())
	Namespace.Add((*GLenumᶜᵖ)(nil).Class())
	Namespace.Add((*GLfloatː2ᵃ)(nil).Class())
	Namespace.Add((*GLfloatː3ᵃ)(nil).Class())
	Namespace.Add((*GLfloatː4ᵃ)(nil).Class())
	Namespace.Add((*GLfloatˢ)(nil).Class())
	Namespace.Add((*GLfloatᵖ)(nil).Class())
	Namespace.Add((*GLfloatᶜᵖ)(nil).Class())
	Namespace.Add((*GLint64ˢ)(nil).Class())
	Namespace.Add((*GLint64ᵖ)(nil).Class())
	Namespace.Add((*GLintː2ᵃ)(nil).Class())
	Namespace.Add((*GLintː3ᵃ)(nil).Class())
	Namespace.Add((*GLintː4ᵃ)(nil).Class())
	Namespace.Add((*GLintˢ)(nil).Class())
	Namespace.Add((*GLintᵖ)(nil).Class())
	Namespace.Add((*GLintᶜᵖ)(nil).Class())
	Namespace.Add((*GLsizeiˢ)(nil).Class())
	Namespace.Add((*GLsizeiᵖ)(nil).Class())
	Namespace.Add((*GLsizeiᶜᵖ)(nil).Class())
	Namespace.Add((*GLubyteˢ)(nil).Class())
	Namespace.Add((*GLubyteᵖ)(nil).Class())
	Namespace.Add((*GLubyteᶜᵖ)(nil).Class())
	Namespace.Add((*GLuint64ˢ)(nil).Class())
	Namespace.Add((*GLuint64ᵖ)(nil).Class())
	Namespace.Add((*GLuint64ᶜᵖ)(nil).Class())
	Namespace.Add((*GLuintˢ)(nil).Class())
	Namespace.Add((*GLuintᵖ)(nil).Class())
	Namespace.Add((*GLuintᶜᵖ)(nil).Class())
	Namespace.Add((*GLvoidˢ)(nil).Class())
	Namespace.Add((*GLvoidᵖ)(nil).Class())
	Namespace.Add((*GlActiveShaderProgram)(nil).Class())
	Namespace.Add((*GlActiveShaderProgramEXT)(nil).Class())
	Namespace.Add((*GlActiveTexture)(nil).Class())
	Namespace.Add((*GlAlphaFuncQCOM)(nil).Class())
	Namespace.Add((*GlAttachShader)(nil).Class())
	Namespace.Add((*GlBeginConditionalRenderNV)(nil).Class())
	Namespace.Add((*GlBeginPerfMonitorAMD)(nil).Class())
	Namespace.Add((*GlBeginPerfQueryINTEL)(nil).Class())
	Namespace.Add((*GlBeginQuery)(nil).Class())
	Namespace.Add((*GlBeginQueryEXT)(nil).Class())
	Namespace.Add((*GlBeginTransformFeedback)(nil).Class())
	Namespace.Add((*GlBindAttribLocation)(nil).Class())
	Namespace.Add((*GlBindBuffer)(nil).Class())
	Namespace.Add((*GlBindBufferBase)(nil).Class())
	Namespace.Add((*GlBindBufferRange)(nil).Class())
	Namespace.Add((*GlBindFramebuffer)(nil).Class())
	Namespace.Add((*GlBindImageTexture)(nil).Class())
	Namespace.Add((*GlBindProgramPipeline)(nil).Class())
	Namespace.Add((*GlBindProgramPipelineEXT)(nil).Class())
	Namespace.Add((*GlBindRenderbuffer)(nil).Class())
	Namespace.Add((*GlBindSampler)(nil).Class())
	Namespace.Add((*GlBindTexture)(nil).Class())
	Namespace.Add((*GlBindTransformFeedback)(nil).Class())
	Namespace.Add((*GlBindVertexArray)(nil).Class())
	Namespace.Add((*GlBindVertexArrayOES)(nil).Class())
	Namespace.Add((*GlBindVertexBuffer)(nil).Class())
	Namespace.Add((*GlBlendBarrierKHR)(nil).Class())
	Namespace.Add((*GlBlendBarrierNV)(nil).Class())
	Namespace.Add((*GlBlendColor)(nil).Class())
	Namespace.Add((*GlBlendEquation)(nil).Class())
	Namespace.Add((*GlBlendEquationSeparate)(nil).Class())
	Namespace.Add((*GlBlendEquationSeparateiEXT)(nil).Class())
	Namespace.Add((*GlBlendEquationSeparateiOES)(nil).Class())
	Namespace.Add((*GlBlendEquationiEXT)(nil).Class())
	Namespace.Add((*GlBlendEquationiOES)(nil).Class())
	Namespace.Add((*GlBlendFunc)(nil).Class())
	Namespace.Add((*GlBlendFuncSeparate)(nil).Class())
	Namespace.Add((*GlBlendFuncSeparateiEXT)(nil).Class())
	Namespace.Add((*GlBlendFuncSeparateiOES)(nil).Class())
	Namespace.Add((*GlBlendFunciEXT)(nil).Class())
	Namespace.Add((*GlBlendFunciOES)(nil).Class())
	Namespace.Add((*GlBlendParameteriNV)(nil).Class())
	Namespace.Add((*GlBlitFramebuffer)(nil).Class())
	Namespace.Add((*GlBlitFramebufferANGLE)(nil).Class())
	Namespace.Add((*GlBlitFramebufferNV)(nil).Class())
	Namespace.Add((*GlBufferData)(nil).Class())
	Namespace.Add((*Voidᶜᵖ)(nil).Class())
	Namespace.Add((*GlBufferStorageEXT)(nil).Class())
	Namespace.Add((*GlBufferSubData)(nil).Class())
	Namespace.Add((*GlCheckFramebufferStatus)(nil).Class())
	Namespace.Add((*GlClear)(nil).Class())
	Namespace.Add((*GlClearBufferfi)(nil).Class())
	Namespace.Add((*GlClearBufferfv)(nil).Class())
	Namespace.Add((*GlClearBufferiv)(nil).Class())
	Namespace.Add((*GlClearBufferuiv)(nil).Class())
	Namespace.Add((*GlClearColor)(nil).Class())
	Namespace.Add((*GlClearDepthf)(nil).Class())
	Namespace.Add((*GlClearStencil)(nil).Class())
	Namespace.Add((*GlClientWaitSync)(nil).Class())
	Namespace.Add((*GlClientWaitSyncAPPLE)(nil).Class())
	Namespace.Add((*GlColorMask)(nil).Class())
	Namespace.Add((*GlColorMaskiEXT)(nil).Class())
	Namespace.Add((*GlColorMaskiOES)(nil).Class())
	Namespace.Add((*GlCompileShader)(nil).Class())
	Namespace.Add((*TexturePointer)(nil).Class())
	Namespace.Add((*GlCompressedTexImage2D)(nil).Class())
	Namespace.Add((*GlCompressedTexImage3D)(nil).Class())
	Namespace.Add((*GlCompressedTexImage3DOES)(nil).Class())
	Namespace.Add((*GlCompressedTexSubImage2D)(nil).Class())
	Namespace.Add((*GlCompressedTexSubImage3D)(nil).Class())
	Namespace.Add((*GlCompressedTexSubImage3DOES)(nil).Class())
	Namespace.Add((*GlCopyBufferSubData)(nil).Class())
	Namespace.Add((*GlCopyBufferSubDataNV)(nil).Class())
	Namespace.Add((*GlCopyImageSubDataEXT)(nil).Class())
	Namespace.Add((*GlCopyImageSubDataOES)(nil).Class())
	Namespace.Add((*GlCopyPathNV)(nil).Class())
	Namespace.Add((*GlCopyTexImage2D)(nil).Class())
	Namespace.Add((*GlCopyTexSubImage2D)(nil).Class())
	Namespace.Add((*GlCopyTexSubImage3D)(nil).Class())
	Namespace.Add((*GlCopyTexSubImage3DOES)(nil).Class())
	Namespace.Add((*GlCopyTextureLevelsAPPLE)(nil).Class())
	Namespace.Add((*GlCoverFillPathInstancedNV)(nil).Class())
	Namespace.Add((*GlCoverFillPathNV)(nil).Class())
	Namespace.Add((*GlCoverStrokePathInstancedNV)(nil).Class())
	Namespace.Add((*GlCoverStrokePathNV)(nil).Class())
	Namespace.Add((*GlCoverageMaskNV)(nil).Class())
	Namespace.Add((*GlCoverageModulationNV)(nil).Class())
	Namespace.Add((*GlCoverageModulationTableNV)(nil).Class())
	Namespace.Add((*GlCoverageOperationNV)(nil).Class())
	Namespace.Add((*GlCreatePerfQueryINTEL)(nil).Class())
	Namespace.Add((*GlCreateProgram)(nil).Class())
	Namespace.Add((*GlCreateShader)(nil).Class())
	Namespace.Add((*GlCreateShaderProgramv)(nil).Class())
	Namespace.Add((*GlCreateShaderProgramvEXT)(nil).Class())
	Namespace.Add((*GlCullFace)(nil).Class())
	Namespace.Add((*GlDebugMessageCallbackKHR)(nil).Class())
	Namespace.Add((*GlDebugMessageControlKHR)(nil).Class())
	Namespace.Add((*GlDebugMessageInsertKHR)(nil).Class())
	Namespace.Add((*GlDeleteBuffers)(nil).Class())
	Namespace.Add((*GlDeleteFencesNV)(nil).Class())
	Namespace.Add((*GlDeleteFramebuffers)(nil).Class())
	Namespace.Add((*GlDeletePathsNV)(nil).Class())
	Namespace.Add((*GlDeletePerfMonitorsAMD)(nil).Class())
	Namespace.Add((*GlDeletePerfQueryINTEL)(nil).Class())
	Namespace.Add((*GlDeleteProgram)(nil).Class())
	Namespace.Add((*PipelineIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteProgramPipelines)(nil).Class())
	Namespace.Add((*GlDeleteProgramPipelinesEXT)(nil).Class())
	Namespace.Add((*QueryIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteQueries)(nil).Class())
	Namespace.Add((*GlDeleteQueriesEXT)(nil).Class())
	Namespace.Add((*RenderbufferIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteRenderbuffers)(nil).Class())
	Namespace.Add((*SamplerIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteSamplers)(nil).Class())
	Namespace.Add((*GlDeleteShader)(nil).Class())
	Namespace.Add((*GlDeleteSync)(nil).Class())
	Namespace.Add((*GlDeleteSyncAPPLE)(nil).Class())
	Namespace.Add((*TextureIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteTextures)(nil).Class())
	Namespace.Add((*TransformFeedbackIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteTransformFeedbacks)(nil).Class())
	Namespace.Add((*VertexArrayIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlDeleteVertexArrays)(nil).Class())
	Namespace.Add((*GlDeleteVertexArraysOES)(nil).Class())
	Namespace.Add((*GlDepthFunc)(nil).Class())
	Namespace.Add((*GlDepthMask)(nil).Class())
	Namespace.Add((*GlDepthRangeArrayfvNV)(nil).Class())
	Namespace.Add((*GlDepthRangeIndexedfNV)(nil).Class())
	Namespace.Add((*GlDepthRangef)(nil).Class())
	Namespace.Add((*GlDetachShader)(nil).Class())
	Namespace.Add((*GlDisable)(nil).Class())
	Namespace.Add((*GlDisableDriverControlQCOM)(nil).Class())
	Namespace.Add((*GlDisableVertexAttribArray)(nil).Class())
	Namespace.Add((*GlDisableiEXT)(nil).Class())
	Namespace.Add((*GlDisableiNV)(nil).Class())
	Namespace.Add((*GlDisableiOES)(nil).Class())
	Namespace.Add((*GlDiscardFramebufferEXT)(nil).Class())
	Namespace.Add((*GlDispatchCompute)(nil).Class())
	Namespace.Add((*GlDispatchComputeIndirect)(nil).Class())
	Namespace.Add((*GlDrawArrays)(nil).Class())
	Namespace.Add((*GlDrawArraysIndirect)(nil).Class())
	Namespace.Add((*GlDrawArraysInstanced)(nil).Class())
	Namespace.Add((*GlDrawArraysInstancedANGLE)(nil).Class())
	Namespace.Add((*GlDrawArraysInstancedBaseInstanceEXT)(nil).Class())
	Namespace.Add((*GlDrawArraysInstancedEXT)(nil).Class())
	Namespace.Add((*GlDrawArraysInstancedNV)(nil).Class())
	Namespace.Add((*GlDrawBuffers)(nil).Class())
	Namespace.Add((*GlDrawBuffersEXT)(nil).Class())
	Namespace.Add((*GlDrawBuffersIndexedEXT)(nil).Class())
	Namespace.Add((*GlDrawBuffersNV)(nil).Class())
	Namespace.Add((*IndicesPointer)(nil).Class())
	Namespace.Add((*GlDrawElements)(nil).Class())
	Namespace.Add((*GlDrawElementsBaseVertexEXT)(nil).Class())
	Namespace.Add((*GlDrawElementsBaseVertexOES)(nil).Class())
	Namespace.Add((*GlDrawElementsIndirect)(nil).Class())
	Namespace.Add((*GlDrawElementsInstanced)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedANGLE)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedBaseInstanceEXT)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedBaseVertexBaseInstanceEXT)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedBaseVertexEXT)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedBaseVertexOES)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedEXT)(nil).Class())
	Namespace.Add((*GlDrawElementsInstancedNV)(nil).Class())
	Namespace.Add((*GlDrawRangeElements)(nil).Class())
	Namespace.Add((*GlDrawRangeElementsBaseVertexEXT)(nil).Class())
	Namespace.Add((*GlDrawRangeElementsBaseVertexOES)(nil).Class())
	Namespace.Add((*GlEGLImageTargetRenderbufferStorageOES)(nil).Class())
	Namespace.Add((*GlEGLImageTargetTexture2DOES)(nil).Class())
	Namespace.Add((*GlEnable)(nil).Class())
	Namespace.Add((*GlEnableDriverControlQCOM)(nil).Class())
	Namespace.Add((*GlEnableVertexAttribArray)(nil).Class())
	Namespace.Add((*GlEnableiEXT)(nil).Class())
	Namespace.Add((*GlEnableiNV)(nil).Class())
	Namespace.Add((*GlEnableiOES)(nil).Class())
	Namespace.Add((*GlEndConditionalRenderNV)(nil).Class())
	Namespace.Add((*GlEndPerfMonitorAMD)(nil).Class())
	Namespace.Add((*GlEndPerfQueryINTEL)(nil).Class())
	Namespace.Add((*GlEndQuery)(nil).Class())
	Namespace.Add((*GlEndQueryEXT)(nil).Class())
	Namespace.Add((*GlEndTilingQCOM)(nil).Class())
	Namespace.Add((*GlEndTransformFeedback)(nil).Class())
	Namespace.Add((*Voidᵖᵖ)(nil).Class())
	Namespace.Add((*GlExtGetBufferPointervQCOM)(nil).Class())
	Namespace.Add((*GlExtGetBuffersQCOM)(nil).Class())
	Namespace.Add((*GlExtGetFramebuffersQCOM)(nil).Class())
	Namespace.Add((*GlExtGetProgramBinarySourceQCOM)(nil).Class())
	Namespace.Add((*ProgramIdᵖ)(nil).Class())
	Namespace.Add((*GlExtGetProgramsQCOM)(nil).Class())
	Namespace.Add((*RenderbufferIdᵖ)(nil).Class())
	Namespace.Add((*GlExtGetRenderbuffersQCOM)(nil).Class())
	Namespace.Add((*ShaderIdᵖ)(nil).Class())
	Namespace.Add((*GlExtGetShadersQCOM)(nil).Class())
	Namespace.Add((*GlExtGetTexLevelParameterivQCOM)(nil).Class())
	Namespace.Add((*GlExtGetTexSubImageQCOM)(nil).Class())
	Namespace.Add((*TextureIdᵖ)(nil).Class())
	Namespace.Add((*GlExtGetTexturesQCOM)(nil).Class())
	Namespace.Add((*GlExtIsProgramBinaryQCOM)(nil).Class())
	Namespace.Add((*GlExtTexObjectStateOverrideiQCOM)(nil).Class())
	Namespace.Add((*GlFenceSync)(nil).Class())
	Namespace.Add((*GlFenceSyncAPPLE)(nil).Class())
	Namespace.Add((*GlFinish)(nil).Class())
	Namespace.Add((*GlFinishFenceNV)(nil).Class())
	Namespace.Add((*GlFlush)(nil).Class())
	Namespace.Add((*GlFlushMappedBufferRange)(nil).Class())
	Namespace.Add((*GlFlushMappedBufferRangeEXT)(nil).Class())
	Namespace.Add((*GlFragmentCoverageColorNV)(nil).Class())
	Namespace.Add((*GlFramebufferParameteri)(nil).Class())
	Namespace.Add((*GlFramebufferRenderbuffer)(nil).Class())
	Namespace.Add((*GlFramebufferSampleLocationsfvNV)(nil).Class())
	Namespace.Add((*GlFramebufferTexture2D)(nil).Class())
	Namespace.Add((*GlFramebufferTexture2DMultisampleEXT)(nil).Class())
	Namespace.Add((*GlFramebufferTexture2DMultisampleIMG)(nil).Class())
	Namespace.Add((*GlFramebufferTexture3DOES)(nil).Class())
	Namespace.Add((*GlFramebufferTextureEXT)(nil).Class())
	Namespace.Add((*GlFramebufferTextureLayer)(nil).Class())
	Namespace.Add((*GlFramebufferTextureMultiviewOVR)(nil).Class())
	Namespace.Add((*GlFramebufferTextureOES)(nil).Class())
	Namespace.Add((*GlFrontFace)(nil).Class())
	Namespace.Add((*GlGenBuffers)(nil).Class())
	Namespace.Add((*GlGenFencesNV)(nil).Class())
	Namespace.Add((*GlGenFramebuffers)(nil).Class())
	Namespace.Add((*GlGenPathsNV)(nil).Class())
	Namespace.Add((*GlGenPerfMonitorsAMD)(nil).Class())
	Namespace.Add((*PipelineIdᵖ)(nil).Class())
	Namespace.Add((*GlGenProgramPipelines)(nil).Class())
	Namespace.Add((*GlGenProgramPipelinesEXT)(nil).Class())
	Namespace.Add((*QueryIdᵖ)(nil).Class())
	Namespace.Add((*GlGenQueries)(nil).Class())
	Namespace.Add((*GlGenQueriesEXT)(nil).Class())
	Namespace.Add((*GlGenRenderbuffers)(nil).Class())
	Namespace.Add((*SamplerIdᵖ)(nil).Class())
	Namespace.Add((*GlGenSamplers)(nil).Class())
	Namespace.Add((*GlGenTextures)(nil).Class())
	Namespace.Add((*TransformFeedbackIdᵖ)(nil).Class())
	Namespace.Add((*GlGenTransformFeedbacks)(nil).Class())
	Namespace.Add((*VertexArrayIdᵖ)(nil).Class())
	Namespace.Add((*GlGenVertexArrays)(nil).Class())
	Namespace.Add((*GlGenVertexArraysOES)(nil).Class())
	Namespace.Add((*GlGenerateMipmap)(nil).Class())
	Namespace.Add((*GlGetActiveAttrib)(nil).Class())
	Namespace.Add((*GlGetActiveUniform)(nil).Class())
	Namespace.Add((*GlGetActiveUniformBlockName)(nil).Class())
	Namespace.Add((*GlGetActiveUniformBlockiv)(nil).Class())
	Namespace.Add((*GlGetActiveUniformsiv)(nil).Class())
	Namespace.Add((*GlGetAttachedShaders)(nil).Class())
	Namespace.Add((*GlGetAttribLocation)(nil).Class())
	Namespace.Add((*GlGetBooleani_v)(nil).Class())
	Namespace.Add((*GlGetBooleanv)(nil).Class())
	Namespace.Add((*GlGetBufferParameteri64v)(nil).Class())
	Namespace.Add((*GlGetBufferParameteriv)(nil).Class())
	Namespace.Add((*GlGetBufferPointerv)(nil).Class())
	Namespace.Add((*GlGetBufferPointervOES)(nil).Class())
	Namespace.Add((*GlGetCoverageModulationTableNV)(nil).Class())
	Namespace.Add((*GlGetDebugMessageLogKHR)(nil).Class())
	Namespace.Add((*GlGetDriverControlStringQCOM)(nil).Class())
	Namespace.Add((*GlGetDriverControlsQCOM)(nil).Class())
	Namespace.Add((*GlGetError)(nil).Class())
	Namespace.Add((*GlGetFenceivNV)(nil).Class())
	Namespace.Add((*GlGetFirstPerfQueryIdINTEL)(nil).Class())
	Namespace.Add((*GlGetFloati_vNV)(nil).Class())
	Namespace.Add((*GlGetFloatv)(nil).Class())
	Namespace.Add((*GlGetFragDataLocation)(nil).Class())
	Namespace.Add((*GlGetFramebufferAttachmentParameteriv)(nil).Class())
	Namespace.Add((*GlGetFramebufferParameteriv)(nil).Class())
	Namespace.Add((*GlGetGraphicsResetStatusEXT)(nil).Class())
	Namespace.Add((*GlGetGraphicsResetStatusKHR)(nil).Class())
	Namespace.Add((*GlGetImageHandleNV)(nil).Class())
	Namespace.Add((*GlGetInteger64i_v)(nil).Class())
	Namespace.Add((*GlGetInteger64v)(nil).Class())
	Namespace.Add((*GlGetInteger64vAPPLE)(nil).Class())
	Namespace.Add((*GlGetIntegeri_v)(nil).Class())
	Namespace.Add((*GlGetIntegeri_vEXT)(nil).Class())
	Namespace.Add((*GlGetIntegerv)(nil).Class())
	Namespace.Add((*GlGetInternalformatSampleivNV)(nil).Class())
	Namespace.Add((*GlGetInternalformativ)(nil).Class())
	Namespace.Add((*GlGetMultisamplefv)(nil).Class())
	Namespace.Add((*GlGetNextPerfQueryIdINTEL)(nil).Class())
	Namespace.Add((*GlGetObjectLabelEXT)(nil).Class())
	Namespace.Add((*GlGetObjectLabelKHR)(nil).Class())
	Namespace.Add((*GlGetObjectPtrLabelKHR)(nil).Class())
	Namespace.Add((*GlGetPathCommandsNV)(nil).Class())
	Namespace.Add((*GlGetPathCoordsNV)(nil).Class())
	Namespace.Add((*GlGetPathDashArrayNV)(nil).Class())
	Namespace.Add((*GlGetPathLengthNV)(nil).Class())
	Namespace.Add((*GlGetPathMetricRangeNV)(nil).Class())
	Namespace.Add((*GlGetPathMetricsNV)(nil).Class())
	Namespace.Add((*GlGetPathParameterfvNV)(nil).Class())
	Namespace.Add((*GlGetPathParameterivNV)(nil).Class())
	Namespace.Add((*GlGetPathSpacingNV)(nil).Class())
	Namespace.Add((*GlGetPerfCounterInfoINTEL)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorCounterDataAMD)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorCounterInfoAMD)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorCounterStringAMD)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorCountersAMD)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorGroupStringAMD)(nil).Class())
	Namespace.Add((*GlGetPerfMonitorGroupsAMD)(nil).Class())
	Namespace.Add((*GlGetPerfQueryDataINTEL)(nil).Class())
	Namespace.Add((*GlGetPerfQueryIdByNameINTEL)(nil).Class())
	Namespace.Add((*GlGetPerfQueryInfoINTEL)(nil).Class())
	Namespace.Add((*GlGetPointervKHR)(nil).Class())
	Namespace.Add((*GlGetProgramBinary)(nil).Class())
	Namespace.Add((*GlGetProgramBinaryOES)(nil).Class())
	Namespace.Add((*GlGetProgramInfoLog)(nil).Class())
	Namespace.Add((*GlGetProgramInterfaceiv)(nil).Class())
	Namespace.Add((*GlGetProgramPipelineInfoLog)(nil).Class())
	Namespace.Add((*GlGetProgramPipelineInfoLogEXT)(nil).Class())
	Namespace.Add((*GlGetProgramPipelineiv)(nil).Class())
	Namespace.Add((*GlGetProgramPipelineivEXT)(nil).Class())
	Namespace.Add((*GlGetProgramResourceIndex)(nil).Class())
	Namespace.Add((*GlGetProgramResourceLocation)(nil).Class())
	Namespace.Add((*GlGetProgramResourceName)(nil).Class())
	Namespace.Add((*GlGetProgramResourcefvNV)(nil).Class())
	Namespace.Add((*GlGetProgramResourceiv)(nil).Class())
	Namespace.Add((*GlGetProgramiv)(nil).Class())
	Namespace.Add((*S64ᵖ)(nil).Class())
	Namespace.Add((*GlGetQueryObjecti64v)(nil).Class())
	Namespace.Add((*GlGetQueryObjecti64vEXT)(nil).Class())
	Namespace.Add((*GlGetQueryObjectivEXT)(nil).Class())
	Namespace.Add((*U64ᵖ)(nil).Class())
	Namespace.Add((*GlGetQueryObjectui64v)(nil).Class())
	Namespace.Add((*GlGetQueryObjectui64vEXT)(nil).Class())
	Namespace.Add((*GlGetQueryObjectuiv)(nil).Class())
	Namespace.Add((*GlGetQueryObjectuivEXT)(nil).Class())
	Namespace.Add((*GlGetQueryiv)(nil).Class())
	Namespace.Add((*GlGetQueryivEXT)(nil).Class())
	Namespace.Add((*GlGetRenderbufferParameteriv)(nil).Class())
	Namespace.Add((*GlGetSamplerParameterIivEXT)(nil).Class())
	Namespace.Add((*GlGetSamplerParameterIivOES)(nil).Class())
	Namespace.Add((*GlGetSamplerParameterIuivEXT)(nil).Class())
	Namespace.Add((*GlGetSamplerParameterIuivOES)(nil).Class())
	Namespace.Add((*GlGetSamplerParameterfv)(nil).Class())
	Namespace.Add((*GlGetSamplerParameteriv)(nil).Class())
	Namespace.Add((*GlGetShaderInfoLog)(nil).Class())
	Namespace.Add((*GlGetShaderPrecisionFormat)(nil).Class())
	Namespace.Add((*GlGetShaderSource)(nil).Class())
	Namespace.Add((*GlGetShaderiv)(nil).Class())
	Namespace.Add((*GlGetString)(nil).Class())
	Namespace.Add((*GlGetStringi)(nil).Class())
	Namespace.Add((*GlGetSynciv)(nil).Class())
	Namespace.Add((*GlGetSyncivAPPLE)(nil).Class())
	Namespace.Add((*GlGetTexLevelParameterfv)(nil).Class())
	Namespace.Add((*GlGetTexLevelParameteriv)(nil).Class())
	Namespace.Add((*GlGetTexParameterIivEXT)(nil).Class())
	Namespace.Add((*GlGetTexParameterIivOES)(nil).Class())
	Namespace.Add((*GlGetTexParameterIuivEXT)(nil).Class())
	Namespace.Add((*GlGetTexParameterIuivOES)(nil).Class())
	Namespace.Add((*GlGetTexParameterfv)(nil).Class())
	Namespace.Add((*GlGetTexParameteriv)(nil).Class())
	Namespace.Add((*GlGetTextureHandleNV)(nil).Class())
	Namespace.Add((*GlGetTextureSamplerHandleNV)(nil).Class())
	Namespace.Add((*GlGetTransformFeedbackVarying)(nil).Class())
	Namespace.Add((*GlGetTranslatedShaderSourceANGLE)(nil).Class())
	Namespace.Add((*GlGetUniformBlockIndex)(nil).Class())
	Namespace.Add((*GlGetUniformIndices)(nil).Class())
	Namespace.Add((*GlGetUniformLocation)(nil).Class())
	Namespace.Add((*GlGetUniformfv)(nil).Class())
	Namespace.Add((*GlGetUniformiv)(nil).Class())
	Namespace.Add((*GlGetUniformuiv)(nil).Class())
	Namespace.Add((*GlGetVertexAttribIiv)(nil).Class())
	Namespace.Add((*GlGetVertexAttribIuiv)(nil).Class())
	Namespace.Add((*GlGetVertexAttribPointerv)(nil).Class())
	Namespace.Add((*GlGetVertexAttribfv)(nil).Class())
	Namespace.Add((*GlGetVertexAttribiv)(nil).Class())
	Namespace.Add((*GlGetnUniformfvEXT)(nil).Class())
	Namespace.Add((*GlGetnUniformfvKHR)(nil).Class())
	Namespace.Add((*GlGetnUniformivEXT)(nil).Class())
	Namespace.Add((*GlGetnUniformivKHR)(nil).Class())
	Namespace.Add((*GlGetnUniformuivKHR)(nil).Class())
	Namespace.Add((*GlHint)(nil).Class())
	Namespace.Add((*GlInsertEventMarkerEXT)(nil).Class())
	Namespace.Add((*GlInterpolatePathsNV)(nil).Class())
	Namespace.Add((*GlInvalidateFramebuffer)(nil).Class())
	Namespace.Add((*GlInvalidateSubFramebuffer)(nil).Class())
	Namespace.Add((*GlIsBuffer)(nil).Class())
	Namespace.Add((*GlIsEnabled)(nil).Class())
	Namespace.Add((*GlIsEnablediEXT)(nil).Class())
	Namespace.Add((*GlIsEnablediNV)(nil).Class())
	Namespace.Add((*GlIsEnablediOES)(nil).Class())
	Namespace.Add((*GlIsFenceNV)(nil).Class())
	Namespace.Add((*GlIsFramebuffer)(nil).Class())
	Namespace.Add((*GlIsImageHandleResidentNV)(nil).Class())
	Namespace.Add((*GlIsPathNV)(nil).Class())
	Namespace.Add((*GlIsPointInFillPathNV)(nil).Class())
	Namespace.Add((*GlIsPointInStrokePathNV)(nil).Class())
	Namespace.Add((*GlIsProgram)(nil).Class())
	Namespace.Add((*GlIsProgramPipeline)(nil).Class())
	Namespace.Add((*GlIsProgramPipelineEXT)(nil).Class())
	Namespace.Add((*GlIsQuery)(nil).Class())
	Namespace.Add((*GlIsQueryEXT)(nil).Class())
	Namespace.Add((*GlIsRenderbuffer)(nil).Class())
	Namespace.Add((*GlIsSampler)(nil).Class())
	Namespace.Add((*GlIsShader)(nil).Class())
	Namespace.Add((*GlIsSync)(nil).Class())
	Namespace.Add((*GlIsSyncAPPLE)(nil).Class())
	Namespace.Add((*GlIsTexture)(nil).Class())
	Namespace.Add((*GlIsTextureHandleResidentNV)(nil).Class())
	Namespace.Add((*GlIsTransformFeedback)(nil).Class())
	Namespace.Add((*GlIsVertexArray)(nil).Class())
	Namespace.Add((*GlIsVertexArrayOES)(nil).Class())
	Namespace.Add((*GlLabelObjectEXT)(nil).Class())
	Namespace.Add((*GlLineWidth)(nil).Class())
	Namespace.Add((*GlLinkProgram)(nil).Class())
	Namespace.Add((*GlMakeImageHandleNonResidentNV)(nil).Class())
	Namespace.Add((*GlMakeImageHandleResidentNV)(nil).Class())
	Namespace.Add((*GlMakeTextureHandleNonResidentNV)(nil).Class())
	Namespace.Add((*GlMakeTextureHandleResidentNV)(nil).Class())
	Namespace.Add((*GlMapBufferOES)(nil).Class())
	Namespace.Add((*GlMapBufferRange)(nil).Class())
	Namespace.Add((*GlMapBufferRangeEXT)(nil).Class())
	Namespace.Add((*GlMatrixLoad3x2fNV)(nil).Class())
	Namespace.Add((*GlMatrixLoad3x3fNV)(nil).Class())
	Namespace.Add((*GlMatrixLoadTranspose3x3fNV)(nil).Class())
	Namespace.Add((*GlMatrixMult3x2fNV)(nil).Class())
	Namespace.Add((*GlMatrixMult3x3fNV)(nil).Class())
	Namespace.Add((*GlMatrixMultTranspose3x3fNV)(nil).Class())
	Namespace.Add((*GlMemoryBarrier)(nil).Class())
	Namespace.Add((*GlMemoryBarrierByRegion)(nil).Class())
	Namespace.Add((*GlMinSampleShadingOES)(nil).Class())
	Namespace.Add((*GlMultiDrawArraysEXT)(nil).Class())
	Namespace.Add((*GlMultiDrawArraysIndirectEXT)(nil).Class())
	Namespace.Add((*Voidᶜᵖᶜᵖ)(nil).Class())
	Namespace.Add((*GlMultiDrawElementsBaseVertexEXT)(nil).Class())
	Namespace.Add((*GlMultiDrawElementsBaseVertexOES)(nil).Class())
	Namespace.Add((*GlMultiDrawElementsEXT)(nil).Class())
	Namespace.Add((*GlMultiDrawElementsIndirectEXT)(nil).Class())
	Namespace.Add((*GlNamedFramebufferSampleLocationsfvNV)(nil).Class())
	Namespace.Add((*GlObjectLabelKHR)(nil).Class())
	Namespace.Add((*GlObjectPtrLabelKHR)(nil).Class())
	Namespace.Add((*GlPatchParameteriEXT)(nil).Class())
	Namespace.Add((*GlPatchParameteriOES)(nil).Class())
	Namespace.Add((*GlPathCommandsNV)(nil).Class())
	Namespace.Add((*GlPathCoordsNV)(nil).Class())
	Namespace.Add((*GlPathCoverDepthFuncNV)(nil).Class())
	Namespace.Add((*GlPathDashArrayNV)(nil).Class())
	Namespace.Add((*GlPathGlyphIndexArrayNV)(nil).Class())
	Namespace.Add((*GlPathGlyphIndexRangeNV)(nil).Class())
	Namespace.Add((*GlPathGlyphRangeNV)(nil).Class())
	Namespace.Add((*GlPathGlyphsNV)(nil).Class())
	Namespace.Add((*GlPathMemoryGlyphIndexArrayNV)(nil).Class())
	Namespace.Add((*GlPathParameterfNV)(nil).Class())
	Namespace.Add((*GlPathParameterfvNV)(nil).Class())
	Namespace.Add((*GlPathParameteriNV)(nil).Class())
	Namespace.Add((*GlPathParameterivNV)(nil).Class())
	Namespace.Add((*GlPathStencilDepthOffsetNV)(nil).Class())
	Namespace.Add((*GlPathStencilFuncNV)(nil).Class())
	Namespace.Add((*GlPathStringNV)(nil).Class())
	Namespace.Add((*GlPathSubCommandsNV)(nil).Class())
	Namespace.Add((*GlPathSubCoordsNV)(nil).Class())
	Namespace.Add((*GlPauseTransformFeedback)(nil).Class())
	Namespace.Add((*GlPixelStorei)(nil).Class())
	Namespace.Add((*GlPointAlongPathNV)(nil).Class())
	Namespace.Add((*GlPolygonModeNV)(nil).Class())
	Namespace.Add((*GlPolygonOffset)(nil).Class())
	Namespace.Add((*GlPopDebugGroupKHR)(nil).Class())
	Namespace.Add((*GlPopGroupMarkerEXT)(nil).Class())
	Namespace.Add((*GlPrimitiveBoundingBoxEXT)(nil).Class())
	Namespace.Add((*GlPrimitiveBoundingBoxOES)(nil).Class())
	Namespace.Add((*GlProgramBinary)(nil).Class())
	Namespace.Add((*GlProgramBinaryOES)(nil).Class())
	Namespace.Add((*GlProgramParameteri)(nil).Class())
	Namespace.Add((*GlProgramParameteriEXT)(nil).Class())
	Namespace.Add((*GlProgramPathFragmentInputGenNV)(nil).Class())
	Namespace.Add((*GlProgramUniform1f)(nil).Class())
	Namespace.Add((*GlProgramUniform1fEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform1fv)(nil).Class())
	Namespace.Add((*GlProgramUniform1fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform1i)(nil).Class())
	Namespace.Add((*GlProgramUniform1iEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform1iv)(nil).Class())
	Namespace.Add((*GlProgramUniform1ivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform1ui)(nil).Class())
	Namespace.Add((*GlProgramUniform1uiEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform1uiv)(nil).Class())
	Namespace.Add((*GlProgramUniform1uivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2f)(nil).Class())
	Namespace.Add((*GlProgramUniform2fEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2fv)(nil).Class())
	Namespace.Add((*GlProgramUniform2fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2i)(nil).Class())
	Namespace.Add((*GlProgramUniform2iEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2iv)(nil).Class())
	Namespace.Add((*GlProgramUniform2ivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2ui)(nil).Class())
	Namespace.Add((*GlProgramUniform2uiEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform2uiv)(nil).Class())
	Namespace.Add((*GlProgramUniform2uivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3f)(nil).Class())
	Namespace.Add((*GlProgramUniform3fEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3fv)(nil).Class())
	Namespace.Add((*GlProgramUniform3fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3i)(nil).Class())
	Namespace.Add((*GlProgramUniform3iEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3iv)(nil).Class())
	Namespace.Add((*GlProgramUniform3ivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3ui)(nil).Class())
	Namespace.Add((*GlProgramUniform3uiEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform3uiv)(nil).Class())
	Namespace.Add((*GlProgramUniform3uivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4f)(nil).Class())
	Namespace.Add((*GlProgramUniform4fEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4fv)(nil).Class())
	Namespace.Add((*GlProgramUniform4fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4i)(nil).Class())
	Namespace.Add((*GlProgramUniform4iEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4iv)(nil).Class())
	Namespace.Add((*GlProgramUniform4ivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4ui)(nil).Class())
	Namespace.Add((*GlProgramUniform4uiEXT)(nil).Class())
	Namespace.Add((*GlProgramUniform4uiv)(nil).Class())
	Namespace.Add((*GlProgramUniform4uivEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformHandleui64NV)(nil).Class())
	Namespace.Add((*GlProgramUniformHandleui64vNV)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2x3fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2x3fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2x4fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix2x4fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3x2fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3x2fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3x4fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix3x4fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4x2fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4x2fvEXT)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4x3fv)(nil).Class())
	Namespace.Add((*GlProgramUniformMatrix4x3fvEXT)(nil).Class())
	Namespace.Add((*GlPushDebugGroupKHR)(nil).Class())
	Namespace.Add((*GlPushGroupMarkerEXT)(nil).Class())
	Namespace.Add((*GlQueryCounterEXT)(nil).Class())
	Namespace.Add((*GlRasterSamplesEXT)(nil).Class())
	Namespace.Add((*GlReadBuffer)(nil).Class())
	Namespace.Add((*GlReadBufferIndexedEXT)(nil).Class())
	Namespace.Add((*GlReadBufferNV)(nil).Class())
	Namespace.Add((*GlReadPixels)(nil).Class())
	Namespace.Add((*GlReadnPixelsEXT)(nil).Class())
	Namespace.Add((*GlReadnPixelsKHR)(nil).Class())
	Namespace.Add((*GlReleaseShaderCompiler)(nil).Class())
	Namespace.Add((*GlRenderbufferStorage)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisample)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisampleANGLE)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisampleAPPLE)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisampleEXT)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisampleIMG)(nil).Class())
	Namespace.Add((*GlRenderbufferStorageMultisampleNV)(nil).Class())
	Namespace.Add((*GlResolveDepthValuesNV)(nil).Class())
	Namespace.Add((*GlResolveMultisampleFramebufferAPPLE)(nil).Class())
	Namespace.Add((*GlResumeTransformFeedback)(nil).Class())
	Namespace.Add((*GlSampleCoverage)(nil).Class())
	Namespace.Add((*GlSampleMaski)(nil).Class())
	Namespace.Add((*GlSamplerParameterIivEXT)(nil).Class())
	Namespace.Add((*GlSamplerParameterIivOES)(nil).Class())
	Namespace.Add((*GlSamplerParameterIuivEXT)(nil).Class())
	Namespace.Add((*GlSamplerParameterIuivOES)(nil).Class())
	Namespace.Add((*GlSamplerParameterf)(nil).Class())
	Namespace.Add((*GlSamplerParameterfv)(nil).Class())
	Namespace.Add((*GlSamplerParameteri)(nil).Class())
	Namespace.Add((*GlSamplerParameteriv)(nil).Class())
	Namespace.Add((*GlScissor)(nil).Class())
	Namespace.Add((*GlScissorArrayvNV)(nil).Class())
	Namespace.Add((*GlScissorIndexedNV)(nil).Class())
	Namespace.Add((*GlScissorIndexedvNV)(nil).Class())
	Namespace.Add((*GlSelectPerfMonitorCountersAMD)(nil).Class())
	Namespace.Add((*GlSetFenceNV)(nil).Class())
	Namespace.Add((*ShaderIdᶜᵖ)(nil).Class())
	Namespace.Add((*GlShaderBinary)(nil).Class())
	Namespace.Add((*GlShaderSource)(nil).Class())
	Namespace.Add((*GlStartTilingQCOM)(nil).Class())
	Namespace.Add((*GlStencilFillPathInstancedNV)(nil).Class())
	Namespace.Add((*GlStencilFillPathNV)(nil).Class())
	Namespace.Add((*GlStencilFunc)(nil).Class())
	Namespace.Add((*GlStencilFuncSeparate)(nil).Class())
	Namespace.Add((*GlStencilMask)(nil).Class())
	Namespace.Add((*GlStencilMaskSeparate)(nil).Class())
	Namespace.Add((*GlStencilOp)(nil).Class())
	Namespace.Add((*GlStencilOpSeparate)(nil).Class())
	Namespace.Add((*GlStencilStrokePathInstancedNV)(nil).Class())
	Namespace.Add((*GlStencilStrokePathNV)(nil).Class())
	Namespace.Add((*GlStencilThenCoverFillPathInstancedNV)(nil).Class())
	Namespace.Add((*GlStencilThenCoverFillPathNV)(nil).Class())
	Namespace.Add((*GlStencilThenCoverStrokePathInstancedNV)(nil).Class())
	Namespace.Add((*GlStencilThenCoverStrokePathNV)(nil).Class())
	Namespace.Add((*GlSubpixelPrecisionBiasNV)(nil).Class())
	Namespace.Add((*GlTestFenceNV)(nil).Class())
	Namespace.Add((*GlTexBufferEXT)(nil).Class())
	Namespace.Add((*GlTexBufferOES)(nil).Class())
	Namespace.Add((*GlTexBufferRangeEXT)(nil).Class())
	Namespace.Add((*GlTexBufferRangeOES)(nil).Class())
	Namespace.Add((*GlTexImage2D)(nil).Class())
	Namespace.Add((*GlTexImage3D)(nil).Class())
	Namespace.Add((*GlTexImage3DOES)(nil).Class())
	Namespace.Add((*GlTexPageCommitmentARB)(nil).Class())
	Namespace.Add((*GlTexParameterIivEXT)(nil).Class())
	Namespace.Add((*GlTexParameterIivOES)(nil).Class())
	Namespace.Add((*GlTexParameterIuivEXT)(nil).Class())
	Namespace.Add((*GlTexParameterIuivOES)(nil).Class())
	Namespace.Add((*GlTexParameterf)(nil).Class())
	Namespace.Add((*GlTexParameterfv)(nil).Class())
	Namespace.Add((*GlTexParameteri)(nil).Class())
	Namespace.Add((*GlTexParameteriv)(nil).Class())
	Namespace.Add((*GlTexStorage1DEXT)(nil).Class())
	Namespace.Add((*GlTexStorage2D)(nil).Class())
	Namespace.Add((*GlTexStorage2DEXT)(nil).Class())
	Namespace.Add((*GlTexStorage2DMultisample)(nil).Class())
	Namespace.Add((*GlTexStorage3D)(nil).Class())
	Namespace.Add((*GlTexStorage3DEXT)(nil).Class())
	Namespace.Add((*GlTexStorage3DMultisampleOES)(nil).Class())
	Namespace.Add((*GlTexSubImage2D)(nil).Class())
	Namespace.Add((*GlTexSubImage3D)(nil).Class())
	Namespace.Add((*GlTexSubImage3DOES)(nil).Class())
	Namespace.Add((*GlTextureStorage1DEXT)(nil).Class())
	Namespace.Add((*GlTextureStorage2DEXT)(nil).Class())
	Namespace.Add((*GlTextureStorage3DEXT)(nil).Class())
	Namespace.Add((*GlTextureViewEXT)(nil).Class())
	Namespace.Add((*GlTextureViewOES)(nil).Class())
	Namespace.Add((*GlTransformFeedbackVaryings)(nil).Class())
	Namespace.Add((*GlTransformPathNV)(nil).Class())
	Namespace.Add((*GlUniform1f)(nil).Class())
	Namespace.Add((*GlUniform1fv)(nil).Class())
	Namespace.Add((*GlUniform1i)(nil).Class())
	Namespace.Add((*GlUniform1iv)(nil).Class())
	Namespace.Add((*GlUniform1ui)(nil).Class())
	Namespace.Add((*GlUniform1uiv)(nil).Class())
	Namespace.Add((*GlUniform2f)(nil).Class())
	Namespace.Add((*GlUniform2fv)(nil).Class())
	Namespace.Add((*GlUniform2i)(nil).Class())
	Namespace.Add((*GlUniform2iv)(nil).Class())
	Namespace.Add((*GlUniform2ui)(nil).Class())
	Namespace.Add((*GlUniform2uiv)(nil).Class())
	Namespace.Add((*GlUniform3f)(nil).Class())
	Namespace.Add((*GlUniform3fv)(nil).Class())
	Namespace.Add((*GlUniform3i)(nil).Class())
	Namespace.Add((*GlUniform3iv)(nil).Class())
	Namespace.Add((*GlUniform3ui)(nil).Class())
	Namespace.Add((*GlUniform3uiv)(nil).Class())
	Namespace.Add((*GlUniform4f)(nil).Class())
	Namespace.Add((*GlUniform4fv)(nil).Class())
	Namespace.Add((*GlUniform4i)(nil).Class())
	Namespace.Add((*GlUniform4iv)(nil).Class())
	Namespace.Add((*GlUniform4ui)(nil).Class())
	Namespace.Add((*GlUniform4uiv)(nil).Class())
	Namespace.Add((*GlUniformBlockBinding)(nil).Class())
	Namespace.Add((*GlUniformHandleui64NV)(nil).Class())
	Namespace.Add((*GlUniformHandleui64vNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix2fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix2x3fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix2x3fvNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix2x4fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix2x4fvNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix3fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix3x2fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix3x2fvNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix3x4fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix3x4fvNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix4fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix4x2fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix4x2fvNV)(nil).Class())
	Namespace.Add((*GlUniformMatrix4x3fv)(nil).Class())
	Namespace.Add((*GlUniformMatrix4x3fvNV)(nil).Class())
	Namespace.Add((*GlUnmapBuffer)(nil).Class())
	Namespace.Add((*GlUnmapBufferOES)(nil).Class())
	Namespace.Add((*GlUseProgram)(nil).Class())
	Namespace.Add((*GlUseProgramStages)(nil).Class())
	Namespace.Add((*GlUseProgramStagesEXT)(nil).Class())
	Namespace.Add((*GlValidateProgram)(nil).Class())
	Namespace.Add((*GlValidateProgramPipeline)(nil).Class())
	Namespace.Add((*GlValidateProgramPipelineEXT)(nil).Class())
	Namespace.Add((*GlVertexAttrib1f)(nil).Class())
	Namespace.Add((*GlVertexAttrib1fv)(nil).Class())
	Namespace.Add((*GlVertexAttrib2f)(nil).Class())
	Namespace.Add((*GlVertexAttrib2fv)(nil).Class())
	Namespace.Add((*GlVertexAttrib3f)(nil).Class())
	Namespace.Add((*GlVertexAttrib3fv)(nil).Class())
	Namespace.Add((*GlVertexAttrib4f)(nil).Class())
	Namespace.Add((*GlVertexAttrib4fv)(nil).Class())
	Namespace.Add((*GlVertexAttribBinding)(nil).Class())
	Namespace.Add((*GlVertexAttribDivisor)(nil).Class())
	Namespace.Add((*GlVertexAttribDivisorANGLE)(nil).Class())
	Namespace.Add((*GlVertexAttribDivisorEXT)(nil).Class())
	Namespace.Add((*GlVertexAttribDivisorNV)(nil).Class())
	Namespace.Add((*GlVertexAttribFormat)(nil).Class())
	Namespace.Add((*GlVertexAttribI4i)(nil).Class())
	Namespace.Add((*GlVertexAttribI4iv)(nil).Class())
	Namespace.Add((*GlVertexAttribI4ui)(nil).Class())
	Namespace.Add((*GlVertexAttribI4uiv)(nil).Class())
	Namespace.Add((*GlVertexAttribIFormat)(nil).Class())
	Namespace.Add((*GlVertexAttribIPointer)(nil).Class())
	Namespace.Add((*GlVertexAttribPointer)(nil).Class())
	Namespace.Add((*GlVertexBindingDivisor)(nil).Class())
	Namespace.Add((*GlViewport)(nil).Class())
	Namespace.Add((*GlViewportArrayvNV)(nil).Class())
	Namespace.Add((*GlViewportIndexedfNV)(nil).Class())
	Namespace.Add((*GlViewportIndexedfvNV)(nil).Class())
	Namespace.Add((*GlWaitSync)(nil).Class())
	Namespace.Add((*GlWaitSyncAPPLE)(nil).Class())
	Namespace.Add((*GlWeightPathsNV)(nil).Class())
	Namespace.Add((*GlXCreateContext)(nil).Class())
	Namespace.Add((*GlXCreateNewContext)(nil).Class())
	Namespace.Add((*GlXMakeContextCurrent)(nil).Class())
	Namespace.Add((*GlXMakeCurrent)(nil).Class())
	Namespace.Add((*Intᵖ)(nil).Class())
	Namespace.Add((*GlXQueryDrawable)(nil).Class())
	Namespace.Add((*GlXSwapBuffers)(nil).Class())
	Namespace.Add((*HDC)(nil).Class())
	Namespace.Add((*HGLRC)(nil).Class())
	Namespace.Add((*Intˢ)(nil).Class())
	Namespace.Add((*Vec2f)(nil).Class())
	Namespace.Add((*Mat2f)(nil).Class())
	Namespace.Add((*Mat2fˢ)(nil).Class())
	Namespace.Add((*Mat2fᵖ)(nil).Class())
	Namespace.Add((*Vec3f)(nil).Class())
	Namespace.Add((*Mat3f)(nil).Class())
	Namespace.Add((*Mat3fˢ)(nil).Class())
	Namespace.Add((*Mat3fᵖ)(nil).Class())
	Namespace.Add((*Vec4f)(nil).Class())
	Namespace.Add((*Mat4f)(nil).Class())
	Namespace.Add((*Mat4fˢ)(nil).Class())
	Namespace.Add((*Mat4fᵖ)(nil).Class())
	Namespace.Add((*PipelineIdˢ)(nil).Class())
	Namespace.Add((*ProgramIdˢ)(nil).Class())
	Namespace.Add((*QueryIdˢ)(nil).Class())
	Namespace.Add((*RenderbufferIdˢ)(nil).Class())
	Namespace.Add((*ReplayBindRenderer)(nil).Class())
	Namespace.Add((*ReplayCreateRenderer)(nil).Class())
	Namespace.Add((*S64ˢ)(nil).Class())
	Namespace.Add((*SamplerIdˢ)(nil).Class())
	Namespace.Add((*ShaderIdˢ)(nil).Class())
	Namespace.Add((*StartTimer)(nil).Class())
	Namespace.Add((*State)(nil).Class())
	Namespace.Add((*StopTimer)(nil).Class())
	Namespace.Add((*SwitchThread)(nil).Class())
	Namespace.Add((*TextureIdˢ)(nil).Class())
	Namespace.Add((*TransformFeedbackIdˢ)(nil).Class())
	Namespace.Add((*U16ˢ)(nil).Class())
	Namespace.Add((*U16ᵖ)(nil).Class())
	Namespace.Add((*U32ˢ)(nil).Class())
	Namespace.Add((*U32ᵖ)(nil).Class())
	Namespace.Add((*U64ˢ)(nil).Class())
	Namespace.Add((*U8ᵖ)(nil).Class())
	Namespace.Add((*Vec2fː2ᵃ)(nil).Class())
	Namespace.Add((*Vec2fˢ)(nil).Class())
	Namespace.Add((*Vec2fᵖ)(nil).Class())
	Namespace.Add((*Vec2i)(nil).Class())
	Namespace.Add((*Vec2iˢ)(nil).Class())
	Namespace.Add((*Vec2iᵖ)(nil).Class())
	Namespace.Add((*Vec3fː3ᵃ)(nil).Class())
	Namespace.Add((*Vec3fˢ)(nil).Class())
	Namespace.Add((*Vec3fᵖ)(nil).Class())
	Namespace.Add((*Vec3i)(nil).Class())
	Namespace.Add((*Vec3iˢ)(nil).Class())
	Namespace.Add((*Vec3iᵖ)(nil).Class())
	Namespace.Add((*Vec4fː4ᵃ)(nil).Class())
	Namespace.Add((*Vec4fˢ)(nil).Class())
	Namespace.Add((*Vec4fᵖ)(nil).Class())
	Namespace.Add((*Vec4i)(nil).Class())
	Namespace.Add((*Vec4iˢ)(nil).Class())
	Namespace.Add((*Vec4iᵖ)(nil).Class())
	Namespace.Add((*VertexArrayIdˢ)(nil).Class())
	Namespace.Add((*Voidˢ)(nil).Class())
	Namespace.Add((*Voidᵖˢ)(nil).Class())
	Namespace.Add((*Voidᶜᵖˢ)(nil).Class())
	Namespace.Add((*Voidᶜᵖᵖ)(nil).Class())
	Namespace.Add((*WglCreateContext)(nil).Class())
	Namespace.Add((*WglCreateContextAttribsARB)(nil).Class())
	Namespace.Add((*WglMakeCurrent)(nil).Class())
	Namespace.Add((*WglSwapBuffers)(nil).Class())
	Namespace.Add((*generate_types)(nil).Class())
}

var (
	binaryIDArchitecture                                     = binary.ID{0x14, 0x53, 0xe8, 0x31, 0x7d, 0x20, 0x5f, 0xbd, 0xad, 0x68, 0x48, 0x67, 0xeb, 0xf6, 0x1c, 0x4f, 0xe8, 0xfc, 0x0e, 0x01}
	binaryIDBackbufferInfo                                   = binary.ID{0x33, 0x30, 0x13, 0x32, 0x31, 0x5d, 0xce, 0x13, 0x1f, 0xa4, 0xe4, 0x27, 0x10, 0xed, 0xd6, 0x58, 0xad, 0x0a, 0x87, 0xac}
	binaryIDColor                                            = binary.ID{0xd0, 0x81, 0x98, 0xcb, 0xe9, 0x4c, 0xb5, 0x68, 0xdf, 0xab, 0x2e, 0xde, 0xed, 0x47, 0x59, 0xd3, 0xa7, 0xaa, 0x6c, 0x98}
	binaryIDBlendState                                       = binary.ID{0xa0, 0x25, 0x10, 0x49, 0xe6, 0xb8, 0xfb, 0x31, 0xf9, 0x74, 0xa1, 0x14, 0x8f, 0x6d, 0x7e, 0x3b, 0x51, 0x1d, 0x3b, 0x7f}
	binaryIDSliceInfo                                        = binary.ID{0x8e, 0xab, 0xab, 0x1b, 0x89, 0x6a, 0x43, 0x9a, 0x3c, 0xa7, 0xb8, 0x43, 0x28, 0x26, 0x72, 0x30, 0x78, 0x26, 0x38, 0xf9}
	binaryIDU8ˢ                                              = binary.ID{0xf7, 0xd9, 0x83, 0x86, 0x77, 0xcc, 0x52, 0xb0, 0x80, 0x2f, 0xfc, 0x47, 0xa5, 0x91, 0x72, 0xd9, 0x3b, 0xcd, 0x65, 0x01}
	binaryIDBuffer                                           = binary.ID{0x72, 0x94, 0x68, 0xa4, 0x0c, 0xe0, 0x5f, 0x61, 0x88, 0x16, 0xab, 0xc8, 0xd6, 0xe8, 0x69, 0xf4, 0x39, 0x2d, 0xc4, 0xbf}
	binaryIDBufferDataPointer                                = binary.ID{0x28, 0x86, 0x55, 0x2c, 0x45, 0xa3, 0x8f, 0x56, 0xed, 0xc2, 0x86, 0x93, 0xaa, 0xf1, 0x64, 0x7b, 0x11, 0xba, 0xff, 0x0b}
	binaryIDBufferIdˢ                                        = binary.ID{0xfc, 0xf6, 0xb4, 0xce, 0x3b, 0x26, 0x76, 0xbb, 0xcc, 0x8f, 0x7e, 0xb8, 0x5c, 0xd5, 0x83, 0x62, 0x52, 0x48, 0x48, 0x78}
	binaryIDBufferIdᵖ                                        = binary.ID{0xdd, 0x87, 0xfa, 0xe3, 0xdf, 0x7b, 0x94, 0x84, 0xf3, 0x9b, 0xcb, 0xce, 0x6b, 0xbd, 0x3c, 0x5e, 0x9d, 0x78, 0xe5, 0x6d}
	binaryIDBufferIdᶜᵖ                                       = binary.ID{0xd9, 0x59, 0x3a, 0xd1, 0xe3, 0x0d, 0x2d, 0x5f, 0x0e, 0x00, 0x47, 0x8b, 0x45, 0x32, 0xa1, 0xb5, 0x13, 0x61, 0xee, 0xc7}
	binaryIDCGLContextObj                                    = binary.ID{0xa6, 0xab, 0x7a, 0x4b, 0x0e, 0xf6, 0x54, 0x78, 0xf8, 0xa3, 0xda, 0x81, 0xd5, 0xc8, 0x50, 0x96, 0xea, 0x6f, 0x2d, 0x7e}
	binaryIDCGLContextObjˢ                                   = binary.ID{0x3e, 0xaa, 0x5d, 0xd6, 0xa9, 0x30, 0xaf, 0x07, 0xac, 0xa4, 0xc1, 0xd6, 0x41, 0xd6, 0x15, 0x75, 0x99, 0xf2, 0xcb, 0x9f}
	binaryIDCGLContextObjᵖ                                   = binary.ID{0x9b, 0xbe, 0x32, 0x83, 0x89, 0x68, 0x87, 0x69, 0x22, 0xa0, 0xcf, 0xd6, 0x63, 0xeb, 0x8f, 0xfb, 0x81, 0x2f, 0x4b, 0x56}
	binaryIDCGLPixelFormatObj                                = binary.ID{0x49, 0x1d, 0x13, 0xc7, 0x27, 0x10, 0xfb, 0xe6, 0xd2, 0xe9, 0x64, 0x94, 0xae, 0xe7, 0x39, 0x7b, 0x78, 0xed, 0x89, 0x2f}
	binaryIDCGLCreateContext                                 = binary.ID{0x87, 0xeb, 0x7f, 0x5e, 0x46, 0xd1, 0x7c, 0xf4, 0x3c, 0x36, 0x44, 0x4b, 0x60, 0x5d, 0xaf, 0xc5, 0x43, 0xc5, 0x2c, 0x61}
	binaryIDCGLFlushDrawable                                 = binary.ID{0x66, 0xb7, 0x6a, 0xa6, 0xc2, 0x2a, 0xab, 0x8e, 0xda, 0x18, 0x0e, 0x76, 0x78, 0xc5, 0xf3, 0xe5, 0xce, 0x2f, 0x91, 0x54}
	binaryIDCGSConnectionIDᵖ                                 = binary.ID{0x56, 0x76, 0x11, 0xe9, 0x30, 0xc9, 0x2c, 0x5e, 0xa4, 0xe8, 0x77, 0x74, 0xff, 0x8f, 0xd0, 0x10, 0xfe, 0x07, 0xbc, 0xe9}
	binaryIDCGSWindowIDᵖ                                     = binary.ID{0xad, 0x99, 0x13, 0x23, 0x11, 0xd0, 0xbb, 0x78, 0x00, 0x65, 0x72, 0xa7, 0x8f, 0xf1, 0x60, 0xab, 0x6a, 0xc0, 0x26, 0xe8}
	binaryIDCGSSurfaceIDᵖ                                    = binary.ID{0x53, 0xa8, 0xa4, 0x0a, 0x4c, 0xf6, 0x2a, 0xe8, 0xfa, 0xb9, 0x5e, 0x78, 0x2b, 0x17, 0x84, 0x22, 0x02, 0xa7, 0x07, 0x0a}
	binaryIDCGLGetSurface                                    = binary.ID{0x74, 0xdc, 0x8d, 0x31, 0x83, 0x7c, 0x92, 0x53, 0x8b, 0xbe, 0x2b, 0x76, 0x07, 0xa2, 0xaf, 0x98, 0x27, 0x26, 0xd2, 0x16}
	binaryIDCGLSetCurrentContext                             = binary.ID{0x88, 0xc1, 0x83, 0x0a, 0xe8, 0x2c, 0x03, 0xa0, 0x88, 0x20, 0xb9, 0x75, 0xfd, 0xb0, 0x14, 0xca, 0xbd, 0x78, 0x2d, 0x6f}
	binaryIDCGSConnectionID                                  = binary.ID{0x21, 0xcd, 0x03, 0x5f, 0x8b, 0x45, 0xa5, 0x23, 0x39, 0x4e, 0xcd, 0x5e, 0x2a, 0xc3, 0xbc, 0xa3, 0x00, 0x61, 0xce, 0x9a}
	binaryIDCGSConnectionIDˢ                                 = binary.ID{0xb8, 0x92, 0xdf, 0x8c, 0xe0, 0x7b, 0x48, 0xa0, 0x2e, 0x72, 0x45, 0x2b, 0x8e, 0x08, 0xbf, 0x3a, 0x9b, 0x4f, 0x5d, 0x2f}
	binaryIDF64ᵖ                                             = binary.ID{0x72, 0xdd, 0xe6, 0x80, 0x3a, 0x16, 0x82, 0xd3, 0x04, 0x9b, 0x5e, 0x5d, 0x7d, 0x72, 0x99, 0x82, 0x3a, 0x24, 0x28, 0xe0}
	binaryIDCGSGetSurfaceBounds                              = binary.ID{0xc3, 0x59, 0xf1, 0x88, 0xb4, 0x83, 0x28, 0xd2, 0x24, 0x88, 0xdf, 0xf5, 0xb5, 0x59, 0x80, 0xdd, 0x77, 0x5e, 0xfa, 0xd7}
	binaryIDCGSSurfaceIDˢ                                    = binary.ID{0xf2, 0xbd, 0x74, 0x6c, 0x45, 0x68, 0xbc, 0x71, 0x0c, 0x0d, 0xc4, 0x8d, 0x7b, 0xc9, 0x40, 0x1b, 0xbe, 0xb9, 0xf5, 0xed}
	binaryIDCGSWindowIDˢ                                     = binary.ID{0x88, 0x07, 0x63, 0x00, 0x36, 0x4d, 0x91, 0x9e, 0x1a, 0x10, 0x78, 0x10, 0xde, 0x80, 0xd8, 0x30, 0x03, 0x4e, 0x64, 0x7a}
	binaryIDCharˢ                                            = binary.ID{0x70, 0x6d, 0x95, 0x73, 0x2e, 0xce, 0x6e, 0x8c, 0xc5, 0x05, 0x19, 0x07, 0x10, 0xbd, 0x46, 0x47, 0x9e, 0x83, 0x55, 0x5c}
	binaryIDCharᵖ                                            = binary.ID{0xac, 0x44, 0x67, 0xfc, 0xf8, 0x14, 0x79, 0xb0, 0x1e, 0xd5, 0xf7, 0xb0, 0xbb, 0xcb, 0x2b, 0x24, 0x88, 0xf4, 0x59, 0xc7}
	binaryIDClearState                                       = binary.ID{0x08, 0xa6, 0xc5, 0x64, 0x5c, 0xc4, 0x9c, 0xf0, 0xad, 0xc5, 0x82, 0x38, 0x2d, 0x37, 0x08, 0xe6, 0x5d, 0x51, 0x63, 0xa0}
	binaryIDRect                                             = binary.ID{0x90, 0xd2, 0x28, 0x1d, 0x44, 0xe8, 0xe1, 0x22, 0x18, 0xef, 0x0a, 0xa6, 0xe7, 0xb3, 0x7b, 0x88, 0xc0, 0x48, 0x38, 0xa2}
	binaryIDRasterizerState                                  = binary.ID{0xba, 0xcc, 0xd9, 0x38, 0xef, 0x30, 0x2c, 0x2e, 0x7b, 0xd7, 0x18, 0x82, 0x47, 0x5c, 0x0f, 0xca, 0xd0, 0x70, 0x0c, 0x27}
	binaryIDVertexPointer                                    = binary.ID{0xf9, 0xce, 0xac, 0x76, 0x09, 0x23, 0xf1, 0xed, 0x02, 0x01, 0xe0, 0x91, 0x9a, 0x2c, 0x78, 0xaf, 0x3d, 0x8f, 0x02, 0xa9}
	binaryIDVertexAttributeArray                             = binary.ID{0xd6, 0xdb, 0x80, 0x6a, 0xa4, 0x37, 0x8a, 0xfb, 0x6f, 0x2b, 0xda, 0x40, 0x36, 0x4d, 0x5a, 0x43, 0xf8, 0x16, 0x3e, 0x41}
	binaryIDRenderbuffer                                     = binary.ID{0x76, 0xf9, 0x8d, 0xf3, 0x8e, 0xe3, 0xa9, 0xb0, 0x01, 0x9c, 0x35, 0xe6, 0xdc, 0x52, 0x1a, 0x40, 0x4d, 0xcc, 0x9b, 0xbd}
	binaryIDImage                                            = binary.ID{0x7a, 0xc7, 0x5e, 0xb9, 0x51, 0x71, 0x08, 0x40, 0x9c, 0xda, 0x78, 0x5a, 0xc0, 0xca, 0x85, 0x97, 0x03, 0xff, 0xdf, 0xbb}
	binaryIDCubemapLevel                                     = binary.ID{0x1c, 0xc1, 0xfa, 0xd8, 0xb4, 0xda, 0xc5, 0x86, 0x02, 0xcd, 0x3a, 0x43, 0xbc, 0x10, 0x9f, 0xe4, 0x55, 0x68, 0xe2, 0x4f}
	binaryIDTexture                                          = binary.ID{0x69, 0x8a, 0xa1, 0xe4, 0xf5, 0xeb, 0x7b, 0xe1, 0x0f, 0x82, 0x1c, 0x57, 0xbe, 0xe5, 0x1d, 0xb1, 0x5c, 0xbb, 0xca, 0xee}
	binaryIDFramebufferAttachmentInfo                        = binary.ID{0x21, 0x80, 0x98, 0x42, 0x29, 0xea, 0x32, 0xcb, 0xf4, 0xb7, 0xcf, 0x20, 0x1f, 0x9d, 0x3f, 0x81, 0x0a, 0xa8, 0xa4, 0xec}
	binaryIDFramebuffer                                      = binary.ID{0x28, 0x3d, 0x03, 0xaf, 0xa7, 0x8a, 0x1a, 0xd7, 0x6f, 0xe8, 0x67, 0x55, 0x11, 0xa5, 0x1c, 0x37, 0x5e, 0x07, 0x92, 0x3b}
	binaryIDGLcharˢ                                          = binary.ID{0xd0, 0xa5, 0xaa, 0x96, 0xb4, 0x18, 0xa8, 0x5c, 0x38, 0x0a, 0x41, 0x88, 0x4b, 0xe7, 0x5e, 0xe7, 0x06, 0xfb, 0x21, 0x73}
	binaryIDShader                                           = binary.ID{0xdb, 0xaa, 0x05, 0x7a, 0x88, 0xde, 0x05, 0xea, 0x19, 0x7d, 0x38, 0x42, 0xf1, 0xe6, 0x37, 0xe1, 0x0c, 0xaf, 0x22, 0x2e}
	binaryIDVertexAttribute                                  = binary.ID{0x48, 0xcc, 0xff, 0xa1, 0xa1, 0x9d, 0x30, 0x10, 0xbe, 0x7e, 0x0b, 0x66, 0xae, 0x30, 0xb0, 0x2e, 0x5f, 0x88, 0x12, 0x8c}
	binaryIDUniform                                          = binary.ID{0x08, 0x78, 0x15, 0x85, 0x85, 0xc7, 0xea, 0x3d, 0xf0, 0xc3, 0x78, 0x69, 0x2b, 0xf3, 0x79, 0x99, 0x8f, 0xbb, 0x00, 0x73}
	binaryIDProgram                                          = binary.ID{0x31, 0x7d, 0xeb, 0xd6, 0x66, 0xf0, 0xad, 0x10, 0x25, 0xbe, 0x80, 0xcd, 0xa7, 0xc5, 0xf1, 0x13, 0xf9, 0x52, 0xc2, 0x28}
	binaryIDVertexArray                                      = binary.ID{0xe6, 0x99, 0xf2, 0x2f, 0xe6, 0xc6, 0x7d, 0x1b, 0xb7, 0x0b, 0x44, 0xfa, 0x62, 0x23, 0xf7, 0x41, 0xad, 0x30, 0xfa, 0x33}
	binaryIDQuery                                            = binary.ID{0x62, 0x44, 0x8a, 0xcf, 0x74, 0x8f, 0xd4, 0xae, 0x50, 0xd3, 0xfd, 0x27, 0xe3, 0x02, 0x90, 0xfe, 0x17, 0x13, 0x0c, 0xa3}
	binaryIDObjects                                          = binary.ID{0x12, 0x48, 0x34, 0xe0, 0x63, 0x96, 0xd4, 0xef, 0x29, 0xea, 0xb8, 0xa4, 0xe1, 0x96, 0x9f, 0x3f, 0xb0, 0xc8, 0x1b, 0xf7}
	binaryIDContext                                          = binary.ID{0xd0, 0x13, 0xab, 0x51, 0x44, 0x9f, 0x32, 0x91, 0x7c, 0x79, 0x9d, 0x0d, 0xa7, 0x7d, 0x38, 0x90, 0x9e, 0x95, 0x9f, 0x7e}
	binaryIDEGLConfig                                        = binary.ID{0xc1, 0xea, 0x31, 0x3f, 0xd1, 0xf0, 0x52, 0x99, 0x82, 0x15, 0x2a, 0x15, 0xc0, 0x95, 0x93, 0x16, 0x2d, 0xd0, 0xaa, 0x58}
	binaryIDEGLContext                                       = binary.ID{0x7e, 0xd7, 0x09, 0xd5, 0xdb, 0xde, 0xd4, 0xf4, 0xc2, 0x44, 0xa3, 0x47, 0xb0, 0x05, 0x91, 0x42, 0x91, 0x5f, 0x12, 0x55}
	binaryIDEGLDisplay                                       = binary.ID{0xdd, 0x44, 0x8d, 0x9b, 0x11, 0x43, 0x6e, 0xec, 0x7b, 0xc7, 0x17, 0x93, 0x81, 0x62, 0x0b, 0xaa, 0x5f, 0xe0, 0xdd, 0x10}
	binaryIDEGLSurface                                       = binary.ID{0x59, 0x9b, 0x7a, 0xba, 0x22, 0x2a, 0xf1, 0x39, 0x66, 0x60, 0x82, 0x26, 0x3c, 0xd3, 0xb7, 0x72, 0x7e, 0x29, 0x27, 0xd0}
	binaryIDEGLintˢ                                          = binary.ID{0x48, 0xe6, 0xdc, 0x7e, 0x40, 0x50, 0x12, 0x29, 0xe0, 0xa8, 0x99, 0x7f, 0x32, 0x4e, 0x0f, 0x9b, 0x1b, 0xa6, 0xd1, 0x64}
	binaryIDEGLintᵖ                                          = binary.ID{0x53, 0x08, 0x3d, 0x08, 0x80, 0xbd, 0xb8, 0x5b, 0xa6, 0x15, 0xbb, 0x5c, 0x03, 0xa1, 0xcd, 0x6a, 0x98, 0xd4, 0x7d, 0x25}
	binaryIDEglCreateContext                                 = binary.ID{0xac, 0x3a, 0xa8, 0x3a, 0x28, 0xf3, 0x5a, 0xea, 0x3c, 0x91, 0x79, 0xd2, 0x7b, 0xc6, 0xf8, 0xb6, 0xd4, 0x07, 0x2b, 0x88}
	binaryIDEglInitialize                                    = binary.ID{0xa3, 0x4b, 0x10, 0xac, 0xe3, 0x34, 0x97, 0x4e, 0x72, 0xe2, 0x44, 0xc6, 0x21, 0x4b, 0x03, 0x0a, 0x2b, 0x01, 0x6e, 0xae}
	binaryIDEglMakeCurrent                                   = binary.ID{0x11, 0xbc, 0xee, 0xf3, 0x15, 0x6b, 0x3c, 0x40, 0x07, 0x40, 0x4c, 0xb3, 0x12, 0x2d, 0x98, 0x0c, 0xd1, 0xf0, 0xb1, 0x1e}
	binaryIDEglQuerySurface                                  = binary.ID{0x14, 0x6c, 0x8d, 0x6c, 0x45, 0xd9, 0xcd, 0xde, 0xde, 0xd0, 0x12, 0xea, 0x3f, 0x95, 0xeb, 0x43, 0xc6, 0x33, 0x40, 0x22}
	binaryIDVoidᵖ                                            = binary.ID{0xf5, 0x56, 0xe8, 0x83, 0x38, 0x05, 0x76, 0x2e, 0x30, 0xd0, 0x53, 0x86, 0x4e, 0x09, 0x56, 0xef, 0x44, 0xc8, 0xce, 0xef}
	binaryIDEglSwapBuffers                                   = binary.ID{0x57, 0x1f, 0xe4, 0x1b, 0x20, 0xa1, 0x87, 0x17, 0x6c, 0x31, 0x05, 0x59, 0x10, 0x83, 0xb5, 0x3a, 0xb0, 0xa9, 0x3c, 0x39}
	binaryIDF64ˢ                                             = binary.ID{0x6a, 0xef, 0x25, 0x73, 0x5b, 0x6a, 0x6b, 0x8e, 0xcd, 0x9c, 0x2f, 0x95, 0x76, 0x64, 0x3d, 0x9d, 0x20, 0x0f, 0x94, 0x39}
	binaryIDFlushPostBuffer                                  = binary.ID{0x26, 0x4e, 0x20, 0xbb, 0xf9, 0x53, 0x75, 0xcd, 0x08, 0x98, 0x6d, 0x82, 0x25, 0x7d, 0xb5, 0xb6, 0x1e, 0xbb, 0xe1, 0xbf}
	binaryIDFramebufferIdˢ                                   = binary.ID{0xf9, 0xf6, 0x67, 0x3a, 0x17, 0x5d, 0xd4, 0x54, 0x8c, 0xa7, 0x85, 0xc0, 0x9c, 0xa3, 0x75, 0x13, 0x6f, 0x10, 0xdd, 0x79}
	binaryIDFramebufferIdᵖ                                   = binary.ID{0xa8, 0x8f, 0xf4, 0xfd, 0x2d, 0xaa, 0xd4, 0x59, 0x93, 0x48, 0xe6, 0xd8, 0x5d, 0x6b, 0xe8, 0x99, 0x72, 0xfa, 0xac, 0xec}
	binaryIDFramebufferIdᶜᵖ                                  = binary.ID{0x8c, 0xa3, 0xf6, 0xdf, 0xc9, 0x8e, 0x08, 0xea, 0x92, 0x56, 0x02, 0x6e, 0x96, 0x2c, 0x3c, 0xdc, 0x63, 0x7b, 0x3b, 0x50}
	binaryIDGLDEBUGPROCKHR                                   = binary.ID{0x21, 0x50, 0x75, 0xdf, 0x3c, 0xfd, 0xf9, 0x5f, 0x40, 0x53, 0x4c, 0x56, 0x10, 0xe8, 0x2f, 0x9a, 0x78, 0x59, 0x7b, 0x48}
	binaryIDGLXContext                                       = binary.ID{0xf7, 0x65, 0x8c, 0x4a, 0x4f, 0xdf, 0x00, 0xcc, 0xb8, 0x97, 0x64, 0x1a, 0xfd, 0x6c, 0x55, 0x30, 0x4a, 0x0f, 0x1e, 0x25}
	binaryIDGLXDrawable                                      = binary.ID{0xe8, 0x9a, 0x82, 0x65, 0x61, 0x45, 0x3f, 0x8b, 0x8b, 0x50, 0xeb, 0x6a, 0x04, 0x78, 0x5c, 0xdc, 0x6b, 0xb5, 0xdc, 0x63}
	binaryIDGLbooleanˢ                                       = binary.ID{0x1e, 0xa5, 0x87, 0x0b, 0xc8, 0x63, 0x6e, 0x02, 0xd7, 0xec, 0x8f, 0x9f, 0x2d, 0x8a, 0xc6, 0x75, 0x5e, 0x99, 0x09, 0x11}
	binaryIDGLbooleanᵖ                                       = binary.ID{0xe3, 0xb8, 0x1f, 0x10, 0x02, 0xc6, 0xe1, 0x4d, 0xd4, 0x5d, 0x7b, 0x45, 0xda, 0xfb, 0x88, 0x85, 0x3b, 0xde, 0x6e, 0x05}
	binaryIDGLcharᵖ                                          = binary.ID{0xf9, 0x5a, 0xd8, 0x24, 0x12, 0x35, 0x54, 0xfc, 0x80, 0xbe, 0xd3, 0x05, 0xbb, 0xe6, 0xa9, 0xa1, 0x63, 0x25, 0xe3, 0x90}
	binaryIDGLcharᶜᵖ                                         = binary.ID{0x8e, 0x46, 0x12, 0x14, 0xec, 0x0d, 0x13, 0x98, 0xad, 0x19, 0x15, 0x46, 0x85, 0xf1, 0xc2, 0x83, 0x8b, 0xef, 0x80, 0xc8}
	binaryIDGLcharᶜᵖˢ                                        = binary.ID{0xb5, 0xe9, 0x5c, 0xe6, 0xe8, 0xf1, 0x7c, 0x45, 0x0c, 0x03, 0x6d, 0x86, 0x0c, 0xa5, 0x55, 0x9c, 0x04, 0x94, 0x28, 0x05}
	binaryIDGLcharᶜᵖᵖ                                        = binary.ID{0xe1, 0xe1, 0xf7, 0xa8, 0x08, 0x4e, 0x41, 0x36, 0x40, 0x25, 0xbd, 0xb7, 0xea, 0xae, 0x67, 0x7d, 0xf5, 0x56, 0xc7, 0x16}
	binaryIDGLcharᶜᵖᶜᵖ                                       = binary.ID{0x03, 0x1e, 0x4a, 0xe9, 0x3a, 0xfb, 0xc6, 0x23, 0x0e, 0x45, 0xed, 0x16, 0x2e, 0x4c, 0xdd, 0xbc, 0x23, 0x28, 0xa7, 0x87}
	binaryIDGLeglImageOES                                    = binary.ID{0xba, 0xfa, 0x36, 0xcd, 0x12, 0x86, 0xf5, 0x6b, 0x64, 0x61, 0xaa, 0x0c, 0xfe, 0xd7, 0x82, 0x15, 0xf2, 0x33, 0xc8, 0x19}
	binaryIDGLenumˢ                                          = binary.ID{0x82, 0x4a, 0x40, 0x44, 0xe6, 0xe7, 0x0e, 0x84, 0xb2, 0x27, 0x74, 0x13, 0x53, 0xa7, 0x81, 0xcb, 0xfe, 0xf4, 0x6f, 0xbe}
	binaryIDGLenumᵖ                                          = binary.ID{0xe8, 0xaa, 0x82, 0x45, 0xc1, 0x4e, 0x0f, 0x89, 0x14, 0xc8, 0x57, 0x33, 0xbb, 0x84, 0xe6, 0xff, 0x7f, 0x08, 0x33, 0xd3}
	binaryIDGLenumᶜᵖ                                         = binary.ID{0xae, 0x16, 0x11, 0x10, 0x2a, 0x41, 0x1a, 0xda, 0x08, 0x37, 0xbc, 0x46, 0x77, 0xf8, 0xe3, 0xe0, 0xc2, 0xd9, 0xb7, 0x2f}
	binaryIDGLfloatː2ᵃ                                       = binary.ID{0x3c, 0x50, 0xe1, 0x60, 0xe7, 0xa3, 0x65, 0xd8, 0xdc, 0x21, 0x90, 0x75, 0xb4, 0xbe, 0x9d, 0xe6, 0x3d, 0x22, 0xf6, 0xe1}
	binaryIDGLfloatː3ᵃ                                       = binary.ID{0x8c, 0xef, 0x73, 0x0a, 0x78, 0xcf, 0x48, 0xa4, 0x63, 0x17, 0x48, 0x3b, 0x99, 0x8b, 0x79, 0x7f, 0x76, 0x62, 0x67, 0xd9}
	binaryIDGLfloatː4ᵃ                                       = binary.ID{0xc5, 0x22, 0x8d, 0xac, 0xf9, 0x40, 0x81, 0x78, 0x19, 0x8b, 0xb2, 0x35, 0x6e, 0x23, 0x27, 0xd8, 0xe2, 0x23, 0xad, 0xf3}
	binaryIDGLfloatˢ                                         = binary.ID{0x67, 0x53, 0xff, 0x1f, 0x77, 0x59, 0xc9, 0x08, 0x77, 0x84, 0x57, 0xac, 0x78, 0x2a, 0x88, 0xb9, 0xc0, 0xbe, 0x87, 0x58}
	binaryIDGLfloatᵖ                                         = binary.ID{0xee, 0x89, 0x74, 0x04, 0x20, 0x2c, 0x92, 0x8b, 0xc2, 0x04, 0x64, 0xa0, 0x83, 0x8d, 0xe7, 0x3f, 0xc8, 0x09, 0xec, 0x31}
	binaryIDGLfloatᶜᵖ                                        = binary.ID{0xe2, 0xac, 0xb2, 0x63, 0xaf, 0xe1, 0x5d, 0xd0, 0x46, 0x19, 0x4d, 0x5b, 0x5f, 0x62, 0x22, 0x0c, 0xb5, 0x25, 0xd6, 0xbd}
	binaryIDGLint64ˢ                                         = binary.ID{0xbb, 0x24, 0xb5, 0xd2, 0x51, 0xb2, 0x5c, 0x5e, 0x4a, 0x00, 0x57, 0x59, 0xcb, 0x50, 0xae, 0xbf, 0xdc, 0x61, 0x61, 0xdb}
	binaryIDGLint64ᵖ                                         = binary.ID{0x22, 0x4e, 0xbd, 0x11, 0x56, 0xe0, 0x24, 0x13, 0xe4, 0x34, 0x94, 0x09, 0x06, 0xe2, 0x00, 0x57, 0x6b, 0x7e, 0x40, 0x6d}
	binaryIDGLintː2ᵃ                                         = binary.ID{0x56, 0x44, 0xa7, 0xf2, 0x5e, 0xad, 0xa5, 0xa1, 0x46, 0x0a, 0x85, 0x57, 0xb0, 0x37, 0xf4, 0xcd, 0x51, 0xfc, 0x64, 0xa7}
	binaryIDGLintː3ᵃ                                         = binary.ID{0xe3, 0x13, 0x2c, 0x0c, 0xd8, 0xa4, 0x11, 0x23, 0x54, 0x86, 0x09, 0x1d, 0x51, 0x29, 0x6f, 0x72, 0x3c, 0xf1, 0x63, 0xc8}
	binaryIDGLintː4ᵃ                                         = binary.ID{0xfd, 0x8c, 0x59, 0x66, 0xc5, 0x2a, 0x80, 0x80, 0x98, 0x92, 0x22, 0xfe, 0x97, 0x1a, 0x67, 0x44, 0x8d, 0xee, 0x50, 0x9e}
	binaryIDGLintˢ                                           = binary.ID{0xa5, 0x5a, 0x7e, 0x66, 0x49, 0x58, 0xe4, 0x73, 0x45, 0x18, 0xb9, 0xcc, 0xff, 0x41, 0x08, 0x20, 0xa6, 0xf2, 0x3b, 0x9c}
	binaryIDGLintᵖ                                           = binary.ID{0x8c, 0x5b, 0x4f, 0xbb, 0x12, 0x09, 0xea, 0x41, 0x8a, 0xb5, 0xb7, 0xcb, 0x4a, 0xfa, 0x9b, 0xf4, 0x44, 0xcb, 0x38, 0x81}
	binaryIDGLintᶜᵖ                                          = binary.ID{0x04, 0x4c, 0x48, 0x95, 0xbc, 0x34, 0xeb, 0xfe, 0xed, 0x9c, 0xab, 0x52, 0x7e, 0x51, 0x7d, 0xa3, 0x50, 0xfb, 0x83, 0x0d}
	binaryIDGLsizeiˢ                                         = binary.ID{0x99, 0x81, 0xbe, 0x6c, 0x6a, 0x23, 0x86, 0x8c, 0x88, 0xbf, 0xec, 0xb4, 0xbb, 0x2d, 0x6c, 0x25, 0x9a, 0x15, 0x02, 0xf1}
	binaryIDGLsizeiᵖ                                         = binary.ID{0xf1, 0x8c, 0xc7, 0xbf, 0x11, 0x21, 0x1c, 0xb1, 0x7b, 0x50, 0x30, 0x2f, 0xb2, 0xd7, 0x99, 0xfd, 0x4e, 0x72, 0x47, 0x47}
	binaryIDGLsizeiᶜᵖ                                        = binary.ID{0x1c, 0x65, 0x1b, 0x21, 0x55, 0x45, 0x1f, 0xb4, 0x2b, 0xd2, 0xf6, 0xf3, 0xde, 0xd2, 0x25, 0x78, 0x10, 0xc7, 0x57, 0x71}
	binaryIDGLubyteˢ                                         = binary.ID{0xc3, 0x54, 0x55, 0x22, 0x67, 0xd9, 0xc3, 0x43, 0x18, 0xc9, 0x8e, 0x29, 0xf2, 0x1f, 0x22, 0x37, 0x59, 0xdb, 0x49, 0x37}
	binaryIDGLubyteᵖ                                         = binary.ID{0xf2, 0xb7, 0xb0, 0x29, 0x66, 0xa2, 0x4b, 0x10, 0x0d, 0x59, 0xdf, 0x16, 0x06, 0x9f, 0x68, 0x42, 0x21, 0x3c, 0xd4, 0xd3}
	binaryIDGLubyteᶜᵖ                                        = binary.ID{0xb5, 0x0d, 0xfc, 0xa5, 0x24, 0x5b, 0x8d, 0xb1, 0x2c, 0x1a, 0x79, 0x84, 0x79, 0x67, 0x97, 0xc6, 0x28, 0x7a, 0x71, 0xb4}
	binaryIDGLuint64ˢ                                        = binary.ID{0x52, 0xf2, 0x5f, 0x2c, 0x15, 0x03, 0xf3, 0x66, 0x9a, 0xaa, 0x21, 0x8c, 0x6f, 0x9e, 0x0f, 0xce, 0x7d, 0xa0, 0xae, 0xa2}
	binaryIDGLuint64ᵖ                                        = binary.ID{0x9c, 0xd3, 0xef, 0x3e, 0x0a, 0x2e, 0xe3, 0x7a, 0xfa, 0xb1, 0x57, 0x79, 0xb3, 0x72, 0xc4, 0x23, 0xea, 0x0a, 0x58, 0x40}
	binaryIDGLuint64ᶜᵖ                                       = binary.ID{0xa9, 0x1e, 0x26, 0x95, 0xae, 0xff, 0xfb, 0x7e, 0x60, 0xfc, 0x49, 0x62, 0x43, 0xb1, 0xd9, 0x47, 0x6b, 0x4b, 0xe2, 0x8b}
	binaryIDGLuintˢ                                          = binary.ID{0xad, 0x6a, 0x6a, 0x06, 0xe5, 0xcd, 0xb4, 0xaf, 0x49, 0x93, 0x63, 0x85, 0x31, 0xa3, 0x2e, 0x71, 0xf3, 0xcc, 0xf0, 0x49}
	binaryIDGLuintᵖ                                          = binary.ID{0x27, 0xaa, 0x79, 0xdf, 0x31, 0xad, 0x72, 0xb1, 0x5f, 0xbb, 0x14, 0x90, 0xaf, 0x95, 0x9e, 0x69, 0x80, 0x1f, 0x44, 0xf8}
	binaryIDGLuintᶜᵖ                                         = binary.ID{0x29, 0x02, 0x1e, 0x6b, 0x99, 0x5e, 0x1b, 0x26, 0x5b, 0x30, 0xf2, 0x71, 0xe4, 0xeb, 0x0b, 0xe9, 0x9d, 0xe9, 0xf8, 0x95}
	binaryIDGLvoidˢ                                          = binary.ID{0xd3, 0xd2, 0x46, 0xdd, 0xb5, 0x76, 0x72, 0xb0, 0x55, 0x41, 0x7a, 0x2f, 0x87, 0x0e, 0x0a, 0x6c, 0x6f, 0x28, 0xb6, 0x7d}
	binaryIDGLvoidᵖ                                          = binary.ID{0x26, 0x9a, 0x9c, 0xb2, 0x53, 0x3c, 0x51, 0x8c, 0x7e, 0x6d, 0xe3, 0x8c, 0xae, 0xf4, 0xc8, 0x0e, 0x3a, 0xdf, 0xf8, 0x4c}
	binaryIDGlActiveShaderProgram                            = binary.ID{0x63, 0x21, 0x0e, 0x72, 0xcb, 0x2a, 0x47, 0xde, 0x9f, 0x8d, 0x24, 0x3c, 0x5a, 0x67, 0xa8, 0x1f, 0x4c, 0xb0, 0x15, 0xa6}
	binaryIDGlActiveShaderProgramEXT                         = binary.ID{0x29, 0x1c, 0x46, 0x6e, 0xed, 0x88, 0x1d, 0x7b, 0x97, 0x0a, 0x6d, 0xe6, 0xa3, 0xb2, 0x47, 0x87, 0xef, 0xbf, 0xb2, 0x8a}
	binaryIDGlActiveTexture                                  = binary.ID{0xd4, 0xe8, 0xee, 0x4a, 0x90, 0xf5, 0x2d, 0x73, 0x2d, 0x28, 0x19, 0x31, 0x46, 0x5d, 0x2e, 0xac, 0x53, 0x19, 0x86, 0x54}
	binaryIDGlAlphaFuncQCOM                                  = binary.ID{0x01, 0x70, 0x2e, 0x94, 0xd9, 0x1a, 0xd4, 0x61, 0x35, 0x08, 0x10, 0xf3, 0x32, 0xa8, 0x58, 0xe7, 0xfb, 0x1f, 0x7e, 0xbe}
	binaryIDGlAttachShader                                   = binary.ID{0x25, 0x23, 0xee, 0xce, 0x3c, 0x37, 0xb6, 0x03, 0x61, 0xc4, 0xb6, 0xbf, 0x06, 0x38, 0xb9, 0x7f, 0x78, 0x85, 0xee, 0x77}
	binaryIDGlBeginConditionalRenderNV                       = binary.ID{0x4d, 0xd5, 0xba, 0x3e, 0xae, 0x81, 0x13, 0x36, 0x9d, 0xa3, 0xcc, 0xb2, 0x1d, 0x78, 0xa9, 0x84, 0xda, 0x08, 0x45, 0xe2}
	binaryIDGlBeginPerfMonitorAMD                            = binary.ID{0x12, 0x48, 0xf0, 0xb8, 0xe0, 0xd5, 0xfa, 0x7d, 0x53, 0xad, 0x47, 0x97, 0x5f, 0x7f, 0x74, 0x7f, 0xec, 0x13, 0xf5, 0xc2}
	binaryIDGlBeginPerfQueryINTEL                            = binary.ID{0xe1, 0x17, 0x39, 0x25, 0x3d, 0x9f, 0xc2, 0xe4, 0xf5, 0x01, 0x2a, 0xba, 0xd7, 0x36, 0x92, 0xde, 0x0d, 0x34, 0xd5, 0xe9}
	binaryIDGlBeginQuery                                     = binary.ID{0x0a, 0xfd, 0xcf, 0xcb, 0x70, 0x71, 0xa7, 0x04, 0x67, 0xf5, 0x84, 0xb6, 0xb4, 0x77, 0x8f, 0x99, 0x1c, 0x69, 0x87, 0x97}
	binaryIDGlBeginQueryEXT                                  = binary.ID{0xc7, 0xa5, 0xb7, 0x25, 0xdb, 0xcc, 0x9c, 0xfe, 0x43, 0xbb, 0xe6, 0x45, 0xc5, 0xe9, 0x7c, 0x4b, 0x6f, 0x84, 0x69, 0x30}
	binaryIDGlBeginTransformFeedback                         = binary.ID{0xe1, 0x82, 0xce, 0xb1, 0x56, 0x27, 0x48, 0x8f, 0x9e, 0xc8, 0x36, 0x88, 0x26, 0x5b, 0xd3, 0xc3, 0xc3, 0x88, 0x5b, 0x87}
	binaryIDGlBindAttribLocation                             = binary.ID{0xab, 0xe2, 0x34, 0x53, 0x26, 0xbc, 0x1d, 0x86, 0xd6, 0x8b, 0xd8, 0xaa, 0xd9, 0x38, 0x2f, 0xca, 0x5a, 0x1d, 0xc0, 0x10}
	binaryIDGlBindBuffer                                     = binary.ID{0x77, 0x0e, 0x5d, 0x2a, 0xdd, 0x4c, 0x52, 0xb8, 0x60, 0xdb, 0x05, 0x08, 0x8a, 0x39, 0x2b, 0x58, 0xe4, 0xf7, 0x72, 0xad}
	binaryIDGlBindBufferBase                                 = binary.ID{0x85, 0xaa, 0x5a, 0x2d, 0x08, 0x1e, 0x5b, 0xc4, 0x31, 0xb8, 0x21, 0x28, 0x4a, 0xeb, 0xae, 0x06, 0x86, 0x94, 0x6f, 0xb5}
	binaryIDGlBindBufferRange                                = binary.ID{0xd9, 0x09, 0xe3, 0x91, 0xd0, 0xef, 0xce, 0xc4, 0x6c, 0xa8, 0xd2, 0x16, 0x2f, 0x3c, 0x7f, 0xa7, 0x4e, 0x62, 0xe6, 0x1d}
	binaryIDGlBindFramebuffer                                = binary.ID{0x69, 0x1e, 0xac, 0x99, 0x53, 0x08, 0xb7, 0x91, 0x2d, 0x45, 0xb5, 0x58, 0xa6, 0x56, 0x07, 0xea, 0xba, 0x86, 0x4b, 0x07}
	binaryIDGlBindImageTexture                               = binary.ID{0x22, 0x1a, 0x40, 0xae, 0xda, 0x76, 0x8c, 0x8c, 0x60, 0x9a, 0xbc, 0xa9, 0x42, 0x4d, 0x1f, 0x22, 0xb1, 0x4c, 0xb1, 0xd7}
	binaryIDGlBindProgramPipeline                            = binary.ID{0x2f, 0x15, 0xf7, 0xcd, 0x57, 0xe0, 0x60, 0xf0, 0x1b, 0x08, 0x8d, 0xc3, 0x06, 0x62, 0xd3, 0x6b, 0x73, 0xa1, 0xeb, 0x81}
	binaryIDGlBindProgramPipelineEXT                         = binary.ID{0x5d, 0x51, 0x1d, 0x4a, 0xf6, 0x6d, 0xa8, 0xd1, 0x83, 0x55, 0x32, 0xe7, 0xe1, 0x04, 0x4e, 0x07, 0x43, 0xa3, 0x74, 0x46}
	binaryIDGlBindRenderbuffer                               = binary.ID{0x62, 0xaa, 0x4d, 0x08, 0x50, 0x1d, 0x16, 0x00, 0x12, 0xe6, 0x25, 0xbd, 0x79, 0xca, 0x02, 0x5c, 0xe2, 0x5b, 0x9a, 0x6f}
	binaryIDGlBindSampler                                    = binary.ID{0xf7, 0xd1, 0xb7, 0xa1, 0xdb, 0xe1, 0x43, 0x42, 0x58, 0x1a, 0x44, 0x14, 0x40, 0x49, 0x3f, 0x31, 0x80, 0xf6, 0xd1, 0xdf}
	binaryIDGlBindTexture                                    = binary.ID{0x49, 0x18, 0x21, 0x98, 0xab, 0xff, 0xcf, 0x46, 0xfb, 0xd5, 0xd8, 0x31, 0x8d, 0xf3, 0x0e, 0x86, 0x16, 0xa3, 0x0e, 0xb2}
	binaryIDGlBindTransformFeedback                          = binary.ID{0xed, 0xb8, 0x97, 0x48, 0x92, 0x72, 0x9a, 0x50, 0x94, 0x6c, 0x07, 0xc1, 0x62, 0x7e, 0x70, 0x1d, 0x8d, 0xcd, 0xb7, 0x45}
	binaryIDGlBindVertexArray                                = binary.ID{0x23, 0x61, 0xb4, 0x30, 0xbe, 0x1c, 0x45, 0xfe, 0x34, 0x7d, 0xaf, 0x2f, 0xb9, 0xf3, 0x4e, 0xef, 0xa3, 0x25, 0x61, 0x46}
	binaryIDGlBindVertexArrayOES                             = binary.ID{0x2c, 0x88, 0xbc, 0x5d, 0x79, 0xf5, 0x34, 0x2a, 0x35, 0xca, 0x72, 0x5c, 0xcf, 0x78, 0xee, 0x4b, 0xe5, 0x5f, 0xc8, 0xb4}
	binaryIDGlBindVertexBuffer                               = binary.ID{0x9d, 0x40, 0xb2, 0xc5, 0x1e, 0xd5, 0x6c, 0x58, 0x27, 0x13, 0x3e, 0x0d, 0xd3, 0x53, 0x7b, 0xba, 0xb7, 0x89, 0xf6, 0x3a}
	binaryIDGlBlendBarrierKHR                                = binary.ID{0xad, 0x82, 0x54, 0xb5, 0x44, 0x3d, 0x10, 0x4b, 0xb0, 0x92, 0x87, 0x8a, 0x4d, 0x63, 0x42, 0x1e, 0x5d, 0xe3, 0x83, 0xb5}
	binaryIDGlBlendBarrierNV                                 = binary.ID{0x88, 0x13, 0x6f, 0x0f, 0xfd, 0x69, 0x5c, 0x6c, 0x59, 0xbb, 0xaf, 0xfc, 0x54, 0xb6, 0x1f, 0xea, 0x5c, 0x3b, 0x58, 0x65}
	binaryIDGlBlendColor                                     = binary.ID{0x67, 0x3c, 0x0a, 0xe9, 0x85, 0x95, 0x30, 0xb5, 0xaf, 0x96, 0xd3, 0x43, 0xed, 0x97, 0xff, 0xd4, 0xf6, 0x14, 0x21, 0xd7}
	binaryIDGlBlendEquation                                  = binary.ID{0x4a, 0xbd, 0xaa, 0x8a, 0x2f, 0x42, 0xdc, 0xff, 0x13, 0x37, 0xfb, 0xb1, 0x2a, 0x25, 0x1d, 0x32, 0x36, 0x31, 0x12, 0xe0}
	binaryIDGlBlendEquationSeparate                          = binary.ID{0x3e, 0x0d, 0xbd, 0xc2, 0x0b, 0x0a, 0x81, 0xd4, 0x58, 0xa4, 0x37, 0x7d, 0x58, 0xdc, 0x4f, 0xcc, 0x5b, 0xa6, 0x09, 0xf4}
	binaryIDGlBlendEquationSeparateiEXT                      = binary.ID{0xf3, 0x45, 0x3b, 0x0f, 0x05, 0x52, 0x80, 0x2d, 0x3e, 0xa6, 0xd1, 0x1f, 0xac, 0x46, 0x48, 0x15, 0x1c, 0x06, 0xcc, 0x55}
	binaryIDGlBlendEquationSeparateiOES                      = binary.ID{0x4a, 0xe5, 0x2d, 0x1d, 0x21, 0xc7, 0xf6, 0x3f, 0xbd, 0x11, 0x55, 0xa4, 0x6c, 0xdb, 0xb0, 0xbd, 0xb6, 0x99, 0x7d, 0x23}
	binaryIDGlBlendEquationiEXT                              = binary.ID{0x6e, 0x7e, 0x7e, 0x2d, 0x2a, 0x0f, 0x67, 0x48, 0xeb, 0x35, 0x4a, 0x3e, 0x2d, 0xfe, 0xf5, 0x4e, 0xc1, 0xd6, 0xc6, 0xa5}
	binaryIDGlBlendEquationiOES                              = binary.ID{0x46, 0x89, 0x07, 0x45, 0xab, 0x6f, 0x7f, 0x81, 0x2a, 0x1d, 0x62, 0xfe, 0x98, 0x1b, 0xef, 0x0f, 0x6a, 0xf3, 0xcd, 0x34}
	binaryIDGlBlendFunc                                      = binary.ID{0xb8, 0x52, 0x83, 0x14, 0x14, 0xff, 0x0c, 0xad, 0xe0, 0x0f, 0x97, 0xb6, 0x07, 0x6c, 0x80, 0xd4, 0x78, 0xf1, 0xf0, 0x91}
	binaryIDGlBlendFuncSeparate                              = binary.ID{0x66, 0xd2, 0xff, 0xf8, 0xf7, 0x95, 0xda, 0x57, 0x16, 0xfb, 0x01, 0x2c, 0x5f, 0x29, 0x53, 0xd5, 0xf7, 0xd0, 0xc0, 0xd2}
	binaryIDGlBlendFuncSeparateiEXT                          = binary.ID{0x8e, 0x9e, 0x4c, 0xf4, 0x1b, 0x8a, 0x3e, 0xdf, 0x02, 0x8a, 0x9f, 0x13, 0x8e, 0xe6, 0xbf, 0x13, 0xf8, 0x76, 0x02, 0x6b}
	binaryIDGlBlendFuncSeparateiOES                          = binary.ID{0x2c, 0x76, 0x35, 0x73, 0x1d, 0xd7, 0xb3, 0xc1, 0x3e, 0x36, 0xb8, 0xe5, 0x38, 0x47, 0x5e, 0xdc, 0x05, 0x26, 0x2a, 0x33}
	binaryIDGlBlendFunciEXT                                  = binary.ID{0x27, 0xc9, 0xc1, 0x56, 0x96, 0xae, 0x08, 0xa5, 0x85, 0x80, 0x37, 0x7f, 0x12, 0x66, 0x30, 0x07, 0x9d, 0x63, 0xf6, 0xc7}
	binaryIDGlBlendFunciOES                                  = binary.ID{0xc9, 0x53, 0x38, 0x83, 0x1e, 0x92, 0x13, 0xb6, 0x19, 0x21, 0xd3, 0xf3, 0x64, 0x74, 0x4c, 0xdd, 0x9f, 0x49, 0x17, 0xb3}
	binaryIDGlBlendParameteriNV                              = binary.ID{0x48, 0x2f, 0xa6, 0x47, 0x3c, 0x55, 0xe9, 0x34, 0xb2, 0x7d, 0x97, 0x4d, 0x20, 0x49, 0x54, 0xa4, 0x7f, 0x18, 0xdd, 0xf3}
	binaryIDGlBlitFramebuffer                                = binary.ID{0x45, 0x48, 0x95, 0x3e, 0x8c, 0x6b, 0x0e, 0x84, 0xbc, 0x13, 0x5a, 0xbb, 0x7d, 0x86, 0x03, 0xfb, 0xe8, 0x5b, 0x96, 0xad}
	binaryIDGlBlitFramebufferANGLE                           = binary.ID{0xcb, 0x1b, 0x9d, 0x45, 0x94, 0xe6, 0xef, 0x95, 0xfc, 0xad, 0x7a, 0x65, 0x7f, 0x6a, 0x2f, 0x67, 0x92, 0xe7, 0x18, 0xbd}
	binaryIDGlBlitFramebufferNV                              = binary.ID{0x22, 0xf2, 0xd1, 0x9a, 0x27, 0x21, 0x02, 0x0e, 0xc3, 0x8b, 0x7b, 0x0e, 0x8c, 0xb1, 0x0d, 0x0b, 0x7e, 0x55, 0x3c, 0x52}
	binaryIDGlBufferData                                     = binary.ID{0x21, 0xdf, 0x8f, 0x68, 0xc9, 0x7a, 0x2d, 0x51, 0x37, 0x85, 0xdd, 0xd5, 0xd7, 0xdf, 0x9f, 0x6d, 0xef, 0xaa, 0x9c, 0x5e}
	binaryIDVoidᶜᵖ                                           = binary.ID{0x39, 0xf4, 0x9d, 0x8a, 0x00, 0x6a, 0x81, 0x37, 0x87, 0x17, 0xac, 0x25, 0x1d, 0xd9, 0x72, 0xb4, 0x88, 0x19, 0x6c, 0x13}
	binaryIDGlBufferStorageEXT                               = binary.ID{0x94, 0x65, 0xa6, 0xd3, 0x2f, 0xa4, 0x35, 0xd4, 0x6d, 0x04, 0xa2, 0xad, 0x14, 0x02, 0xa5, 0x80, 0x7c, 0xbc, 0x91, 0xb1}
	binaryIDGlBufferSubData                                  = binary.ID{0x20, 0x2f, 0x40, 0x3d, 0xfe, 0x18, 0x48, 0xbe, 0x93, 0x2e, 0xdb, 0x91, 0xfa, 0x00, 0x25, 0x50, 0x74, 0x1e, 0x77, 0xde}
	binaryIDGlCheckFramebufferStatus                         = binary.ID{0xba, 0xea, 0x19, 0xe9, 0xb9, 0xea, 0x6b, 0x8f, 0x6f, 0x9d, 0x8b, 0xd3, 0x5a, 0x2f, 0x44, 0xe5, 0x4a, 0xd5, 0x08, 0xcb}
	binaryIDGlClear                                          = binary.ID{0x03, 0xca, 0x54, 0x0f, 0x2b, 0xe1, 0xf4, 0x2c, 0x82, 0xc2, 0x77, 0x8f, 0x5a, 0x56, 0x20, 0x96, 0x0e, 0x9a, 0xff, 0xe0}
	binaryIDGlClearBufferfi                                  = binary.ID{0xf2, 0xd8, 0x4f, 0xf5, 0x9c, 0x98, 0xcc, 0x7a, 0xd8, 0x9a, 0x14, 0x14, 0x44, 0xea, 0x34, 0x11, 0x18, 0x22, 0x29, 0xd5}
	binaryIDGlClearBufferfv                                  = binary.ID{0xb9, 0xe3, 0xb9, 0x41, 0x18, 0x92, 0x4d, 0xf8, 0x4b, 0x0d, 0xcf, 0x32, 0x35, 0x29, 0x5d, 0x8d, 0x39, 0x06, 0xa8, 0x5a}
	binaryIDGlClearBufferiv                                  = binary.ID{0x91, 0x4b, 0x23, 0x8d, 0x45, 0x89, 0xd8, 0xc3, 0x60, 0xd0, 0xcf, 0x2d, 0x7c, 0x2f, 0x40, 0x04, 0x4c, 0xee, 0xe0, 0xc9}
	binaryIDGlClearBufferuiv                                 = binary.ID{0x1a, 0xb1, 0x89, 0xdb, 0x65, 0x65, 0xdd, 0xd5, 0x3d, 0x7e, 0x82, 0xb4, 0xcd, 0x1c, 0x3c, 0x5b, 0x4d, 0xea, 0x27, 0x11}
	binaryIDGlClearColor                                     = binary.ID{0x59, 0xef, 0x2f, 0xaa, 0xd5, 0x30, 0x9d, 0x69, 0xe4, 0x97, 0xf5, 0x86, 0x52, 0x54, 0x26, 0x80, 0xae, 0xef, 0x46, 0x50}
	binaryIDGlClearDepthf                                    = binary.ID{0x06, 0x7c, 0x3c, 0x31, 0x53, 0xdd, 0xfa, 0x1d, 0xd5, 0x67, 0xe1, 0x6a, 0xed, 0xab, 0x53, 0xf5, 0xdf, 0x20, 0x82, 0xe3}
	binaryIDGlClearStencil                                   = binary.ID{0xcf, 0xf4, 0x84, 0x08, 0x83, 0x47, 0x09, 0x6a, 0x66, 0xac, 0xbf, 0xee, 0x05, 0xb5, 0x57, 0x40, 0xa8, 0x5d, 0x8a, 0x91}
	binaryIDGlClientWaitSync                                 = binary.ID{0x0b, 0x68, 0xeb, 0x64, 0xf5, 0xef, 0x38, 0xd0, 0x9f, 0xbf, 0x73, 0x4c, 0xf2, 0xdd, 0xc5, 0xe5, 0xd8, 0xd7, 0xe1, 0x84}
	binaryIDGlClientWaitSyncAPPLE                            = binary.ID{0x66, 0xc0, 0xa1, 0x35, 0xec, 0x45, 0x5d, 0xed, 0x8d, 0x2e, 0x77, 0x60, 0x07, 0xde, 0x10, 0x29, 0x7b, 0x8f, 0x5a, 0xa8}
	binaryIDGlColorMask                                      = binary.ID{0x08, 0x8e, 0x3b, 0xb6, 0x7d, 0x88, 0x07, 0x6c, 0x0b, 0x69, 0xba, 0xf5, 0x56, 0x97, 0xc3, 0xde, 0x2a, 0xa6, 0xc7, 0x5b}
	binaryIDGlColorMaskiEXT                                  = binary.ID{0xd8, 0xb9, 0x63, 0xa6, 0xb9, 0xe9, 0xbf, 0xba, 0xc9, 0x91, 0x91, 0x63, 0xa1, 0x78, 0x8c, 0xa4, 0x0f, 0x1c, 0x17, 0x95}
	binaryIDGlColorMaskiOES                                  = binary.ID{0x22, 0xb2, 0xa8, 0x79, 0x8c, 0x2b, 0x70, 0x10, 0x7c, 0xc2, 0x79, 0xf6, 0xce, 0xe5, 0x03, 0x13, 0xd8, 0x40, 0x22, 0xc2}
	binaryIDGlCompileShader                                  = binary.ID{0xce, 0x1e, 0x7c, 0xbf, 0xf7, 0xb7, 0x95, 0x6d, 0x38, 0x5d, 0x42, 0x6d, 0x1e, 0xba, 0x0e, 0xd5, 0xf4, 0xa9, 0xe7, 0x30}
	binaryIDTexturePointer                                   = binary.ID{0x34, 0x65, 0x45, 0xf1, 0x2d, 0xda, 0x70, 0xcb, 0x48, 0xb2, 0x29, 0x9b, 0xb3, 0x7f, 0xe4, 0xa6, 0x96, 0xb2, 0x64, 0xe7}
	binaryIDGlCompressedTexImage2D                           = binary.ID{0x49, 0x15, 0xd8, 0xed, 0xda, 0xa2, 0x48, 0x84, 0xe3, 0x07, 0xe1, 0x7d, 0x93, 0x8f, 0xb0, 0x65, 0xfa, 0x8d, 0x6b, 0x77}
	binaryIDGlCompressedTexImage3D                           = binary.ID{0x79, 0xb7, 0x8d, 0xb7, 0xeb, 0xe6, 0x65, 0x24, 0x3f, 0x08, 0xdf, 0x1d, 0x17, 0x8b, 0xe6, 0x2b, 0xe7, 0xde, 0xa4, 0x3f}
	binaryIDGlCompressedTexImage3DOES                        = binary.ID{0xa3, 0xa7, 0xe6, 0x12, 0xa7, 0xd5, 0x88, 0x65, 0xd8, 0x46, 0x48, 0xe2, 0x44, 0x1c, 0x4c, 0x79, 0x95, 0x29, 0x66, 0x4b}
	binaryIDGlCompressedTexSubImage2D                        = binary.ID{0xa1, 0xe7, 0x4b, 0x8e, 0x54, 0x07, 0x10, 0x8a, 0xae, 0x42, 0x96, 0x75, 0x3e, 0x55, 0x1d, 0x3d, 0x58, 0xaf, 0x31, 0x58}
	binaryIDGlCompressedTexSubImage3D                        = binary.ID{0x2a, 0xc8, 0xe7, 0xe3, 0x0c, 0x09, 0x0c, 0x49, 0xb6, 0x2c, 0x4f, 0xd2, 0xbd, 0xc8, 0xcd, 0xad, 0x57, 0x98, 0x12, 0xfa}
	binaryIDGlCompressedTexSubImage3DOES                     = binary.ID{0xeb, 0x92, 0x20, 0x2a, 0xf2, 0x7a, 0x0c, 0x41, 0xa1, 0x69, 0x03, 0x9d, 0x60, 0x3a, 0xeb, 0xd1, 0x38, 0x3a, 0x60, 0x01}
	binaryIDGlCopyBufferSubData                              = binary.ID{0xb9, 0x7d, 0x45, 0x29, 0x67, 0x61, 0x18, 0x61, 0x5a, 0xcd, 0x30, 0x4f, 0x9a, 0xaa, 0x35, 0x6d, 0xfe, 0x59, 0xc7, 0x7b}
	binaryIDGlCopyBufferSubDataNV                            = binary.ID{0xbd, 0x1a, 0x1d, 0x49, 0x41, 0x26, 0x00, 0x1f, 0xe0, 0x2e, 0x25, 0x72, 0x81, 0xe2, 0x38, 0x7e, 0x1f, 0xcb, 0xfb, 0xb1}
	binaryIDGlCopyImageSubDataEXT                            = binary.ID{0xd7, 0xca, 0xe8, 0x88, 0x23, 0xde, 0x41, 0x13, 0x76, 0x93, 0x10, 0xc4, 0x1f, 0x00, 0xe7, 0x14, 0x90, 0x76, 0xe4, 0x4b}
	binaryIDGlCopyImageSubDataOES                            = binary.ID{0x73, 0xa7, 0xa4, 0x84, 0x0e, 0x79, 0xfd, 0x17, 0xac, 0x8f, 0x38, 0x25, 0x61, 0x99, 0x0f, 0x12, 0xc5, 0xca, 0x9b, 0xde}
	binaryIDGlCopyPathNV                                     = binary.ID{0x6f, 0xb0, 0x71, 0xa2, 0x14, 0xbb, 0x6c, 0xd2, 0x68, 0x92, 0x9f, 0x83, 0xc1, 0x6c, 0x0b, 0x16, 0xc9, 0xf7, 0x81, 0x71}
	binaryIDGlCopyTexImage2D                                 = binary.ID{0xd2, 0x14, 0xc3, 0x0f, 0xb0, 0x5a, 0xc2, 0x94, 0x88, 0x0b, 0xf6, 0xc8, 0x17, 0x75, 0x38, 0x86, 0x4e, 0xb2, 0xe2, 0xa1}
	binaryIDGlCopyTexSubImage2D                              = binary.ID{0xcc, 0xf8, 0x58, 0x87, 0x73, 0x70, 0xa9, 0xda, 0xd1, 0x12, 0x17, 0xaf, 0xa2, 0xab, 0xc6, 0x2d, 0xce, 0x04, 0xa1, 0xae}
	binaryIDGlCopyTexSubImage3D                              = binary.ID{0x8f, 0x8d, 0x3e, 0xee, 0x70, 0xe2, 0xfe, 0x0f, 0x83, 0x1d, 0xf0, 0x77, 0xb1, 0xef, 0xac, 0xa7, 0x88, 0x17, 0x4f, 0x13}
	binaryIDGlCopyTexSubImage3DOES                           = binary.ID{0x63, 0x2a, 0x48, 0x12, 0xea, 0xd1, 0xa4, 0x6a, 0x98, 0x7a, 0x67, 0x25, 0xb0, 0x59, 0xca, 0x40, 0x7b, 0x4f, 0x77, 0x26}
	binaryIDGlCopyTextureLevelsAPPLE                         = binary.ID{0x5e, 0xbe, 0x5a, 0xf4, 0x8b, 0xee, 0xe4, 0xce, 0x39, 0xbb, 0xce, 0x8b, 0x5f, 0x70, 0xc3, 0xaa, 0x71, 0x8a, 0xe7, 0x9a}
	binaryIDGlCoverFillPathInstancedNV                       = binary.ID{0xf6, 0x95, 0x6b, 0xc5, 0x19, 0x5d, 0x95, 0x7e, 0x1a, 0x7f, 0xa2, 0x24, 0x65, 0x3d, 0x2d, 0x6b, 0x0a, 0x0b, 0xf8, 0x1c}
	binaryIDGlCoverFillPathNV                                = binary.ID{0x21, 0x4b, 0x9d, 0x34, 0xca, 0xb3, 0xa9, 0xa9, 0x3d, 0x8f, 0x4e, 0x1b, 0x52, 0xca, 0x0e, 0xd8, 0x13, 0xac, 0xcf, 0x81}
	binaryIDGlCoverStrokePathInstancedNV                     = binary.ID{0x25, 0x06, 0xd1, 0x0c, 0x88, 0x6c, 0xfe, 0xa6, 0xa7, 0xfa, 0x87, 0x9e, 0x88, 0x57, 0xeb, 0x3d, 0xf4, 0xe3, 0x8a, 0xfb}
	binaryIDGlCoverStrokePathNV                              = binary.ID{0x51, 0x20, 0x74, 0x5e, 0x5e, 0xa5, 0x44, 0x63, 0x20, 0xf0, 0x43, 0x56, 0xe7, 0x4f, 0xa4, 0xa6, 0x16, 0xbd, 0x8b, 0x53}
	binaryIDGlCoverageMaskNV                                 = binary.ID{0xc2, 0x89, 0x91, 0xeb, 0xb6, 0xb4, 0x0a, 0x5e, 0xb2, 0x73, 0x4a, 0xf8, 0xb9, 0xd3, 0xd7, 0x01, 0xb5, 0x33, 0x1f, 0xe5}
	binaryIDGlCoverageModulationNV                           = binary.ID{0xa5, 0x76, 0xbf, 0x1e, 0x63, 0x63, 0x1e, 0xed, 0x26, 0xf0, 0x76, 0xe0, 0x60, 0x91, 0x99, 0x5f, 0x4f, 0x63, 0x58, 0xcd}
	binaryIDGlCoverageModulationTableNV                      = binary.ID{0x88, 0xd5, 0x9f, 0xb0, 0xea, 0x0a, 0x5a, 0x25, 0x69, 0x0c, 0x7e, 0x87, 0x1f, 0xa5, 0x69, 0xcb, 0x8b, 0x81, 0xc4, 0xc5}
	binaryIDGlCoverageOperationNV                            = binary.ID{0xb6, 0x7b, 0xca, 0x16, 0x3e, 0xf9, 0x8c, 0x79, 0x20, 0x2b, 0x0e, 0x3b, 0xd2, 0xe6, 0x5c, 0x00, 0xa4, 0xae, 0x5f, 0x97}
	binaryIDGlCreatePerfQueryINTEL                           = binary.ID{0xdf, 0xf1, 0xca, 0x61, 0x7b, 0x37, 0x31, 0x85, 0x76, 0xd2, 0x73, 0x11, 0xa5, 0x2d, 0x18, 0xee, 0x78, 0x08, 0x3a, 0x1f}
	binaryIDGlCreateProgram                                  = binary.ID{0x54, 0xa2, 0x4c, 0x27, 0x9f, 0x12, 0x2c, 0xfb, 0x4f, 0x47, 0x54, 0xd8, 0xfa, 0x4b, 0x69, 0xf6, 0x3e, 0x65, 0x36, 0xc2}
	binaryIDGlCreateShader                                   = binary.ID{0x90, 0x0e, 0x1e, 0xd1, 0xfa, 0xbf, 0xa9, 0xae, 0x70, 0x9c, 0xa0, 0xde, 0x0d, 0x4e, 0x72, 0x24, 0x68, 0x5f, 0xff, 0x17}
	binaryIDGlCreateShaderProgramv                           = binary.ID{0xc3, 0x69, 0x0b, 0x08, 0xa0, 0x15, 0x9f, 0xcd, 0x53, 0xc1, 0x81, 0x31, 0x23, 0x53, 0x6e, 0xcd, 0x42, 0x47, 0x60, 0xf9}
	binaryIDGlCreateShaderProgramvEXT                        = binary.ID{0xb3, 0x09, 0x45, 0xba, 0xcc, 0xb7, 0x80, 0x65, 0x3e, 0x1a, 0xf8, 0x37, 0xc8, 0x22, 0xe1, 0x22, 0xda, 0xbe, 0xf8, 0x98}
	binaryIDGlCullFace                                       = binary.ID{0xbb, 0xec, 0x72, 0x6d, 0xbc, 0x88, 0x95, 0xe8, 0xe0, 0x4d, 0x83, 0xd4, 0x75, 0xc2, 0xa1, 0x5d, 0x25, 0xdf, 0x38, 0x1f}
	binaryIDGlDebugMessageCallbackKHR                        = binary.ID{0x36, 0x25, 0xc3, 0x9f, 0xa8, 0x55, 0xaa, 0x1f, 0x73, 0x17, 0xd4, 0xbd, 0x8d, 0x87, 0x36, 0x27, 0x16, 0xba, 0x4b, 0x9b}
	binaryIDGlDebugMessageControlKHR                         = binary.ID{0xb1, 0x31, 0xb6, 0xa5, 0x8f, 0x6a, 0xf2, 0x90, 0x81, 0xae, 0x0d, 0xd6, 0x88, 0x1e, 0x32, 0x25, 0xf7, 0xe2, 0x7b, 0x4a}
	binaryIDGlDebugMessageInsertKHR                          = binary.ID{0x08, 0x2d, 0x41, 0x74, 0xbd, 0x81, 0x17, 0x57, 0xa0, 0x23, 0x02, 0x6d, 0x3b, 0x7e, 0xd9, 0x13, 0x65, 0x36, 0xa6, 0x14}
	binaryIDGlDeleteBuffers                                  = binary.ID{0x8e, 0xbe, 0xc5, 0xd4, 0x07, 0xe6, 0x79, 0xe1, 0x39, 0x7c, 0x8a, 0xfe, 0xd4, 0x18, 0xe1, 0xbd, 0xbf, 0x43, 0xb9, 0xc1}
	binaryIDGlDeleteFencesNV                                 = binary.ID{0x4e, 0x46, 0xf9, 0x3e, 0x9c, 0x75, 0x22, 0x8a, 0xc4, 0x4a, 0x85, 0xcc, 0xf6, 0xb1, 0xc0, 0x92, 0x60, 0x36, 0x47, 0x0f}
	binaryIDGlDeleteFramebuffers                             = binary.ID{0x9c, 0x20, 0xe5, 0xad, 0x48, 0xfd, 0xe0, 0x88, 0x0f, 0xc4, 0x0d, 0xa2, 0xc5, 0x33, 0x39, 0xbf, 0x8e, 0x4a, 0x2f, 0x12}
	binaryIDGlDeletePathsNV                                  = binary.ID{0xa0, 0xe2, 0x00, 0x8b, 0xa7, 0xf9, 0x8f, 0x0a, 0x88, 0x0d, 0x2d, 0xdb, 0xfa, 0xb6, 0x24, 0x68, 0xf0, 0x61, 0xdd, 0xac}
	binaryIDGlDeletePerfMonitorsAMD                          = binary.ID{0x8e, 0x14, 0x9f, 0x81, 0x14, 0xc0, 0x6a, 0xff, 0xc2, 0xf6, 0x7e, 0xb3, 0x3f, 0x14, 0x7e, 0x78, 0x05, 0x55, 0x32, 0x6e}
	binaryIDGlDeletePerfQueryINTEL                           = binary.ID{0x7c, 0xa8, 0x95, 0x9f, 0x0d, 0x55, 0x35, 0x44, 0x47, 0xcf, 0x74, 0xd7, 0x64, 0x47, 0xcf, 0x38, 0xd2, 0x61, 0x94, 0x75}
	binaryIDGlDeleteProgram                                  = binary.ID{0x3d, 0x9f, 0xd2, 0xe3, 0xa2, 0x70, 0x3d, 0x38, 0x17, 0x8a, 0x71, 0xca, 0xbe, 0xb4, 0x8c, 0x97, 0x00, 0x75, 0x9f, 0x2f}
	binaryIDPipelineIdᶜᵖ                                     = binary.ID{0x0a, 0x4f, 0x10, 0x67, 0x49, 0xc8, 0x93, 0x2c, 0xeb, 0x36, 0x80, 0x8a, 0x02, 0x6a, 0xa9, 0x03, 0xef, 0x13, 0xc1, 0xfd}
	binaryIDGlDeleteProgramPipelines                         = binary.ID{0x14, 0xe5, 0x92, 0x25, 0x9e, 0x8a, 0x89, 0xfb, 0xa4, 0x4c, 0x23, 0x1a, 0x8a, 0x4c, 0x4a, 0x70, 0x1d, 0xf4, 0x99, 0xba}
	binaryIDGlDeleteProgramPipelinesEXT                      = binary.ID{0xc0, 0x9f, 0x28, 0xa5, 0xd8, 0x49, 0x25, 0xf6, 0xea, 0x03, 0xa6, 0xd5, 0xd5, 0xef, 0x57, 0x0a, 0xf2, 0x0e, 0x5d, 0x99}
	binaryIDQueryIdᶜᵖ                                        = binary.ID{0x64, 0x17, 0xe9, 0xaf, 0xe7, 0x7b, 0xd7, 0xf0, 0x34, 0xd2, 0x9e, 0xf1, 0x28, 0xfe, 0x14, 0x86, 0x26, 0x11, 0xc5, 0x3d}
	binaryIDGlDeleteQueries                                  = binary.ID{0xb5, 0xa4, 0x36, 0x99, 0x5f, 0x02, 0x2f, 0xcd, 0x9e, 0xce, 0x31, 0x1d, 0xe3, 0x64, 0xaa, 0xed, 0xf4, 0x46, 0x29, 0x6c}
	binaryIDGlDeleteQueriesEXT                               = binary.ID{0x0f, 0xad, 0x21, 0x94, 0x70, 0xe0, 0x7b, 0x5b, 0x89, 0x86, 0x54, 0xc1, 0x0a, 0x2a, 0xd5, 0x41, 0xb1, 0x87, 0xef, 0x60}
	binaryIDRenderbufferIdᶜᵖ                                 = binary.ID{0x8b, 0x29, 0xe6, 0x5c, 0xdc, 0xee, 0x14, 0x3d, 0x3b, 0x65, 0xd8, 0xdc, 0x4b, 0x61, 0x39, 0x38, 0x8d, 0xbb, 0x2d, 0x10}
	binaryIDGlDeleteRenderbuffers                            = binary.ID{0x40, 0x8c, 0x81, 0xda, 0xbd, 0x1c, 0x17, 0xcb, 0x13, 0x42, 0xf6, 0xbe, 0x5e, 0x04, 0xa5, 0xa6, 0x53, 0x42, 0x2d, 0x2b}
	binaryIDSamplerIdᶜᵖ                                      = binary.ID{0x03, 0x8d, 0x54, 0x74, 0xd2, 0xf4, 0xaf, 0x0e, 0xd7, 0x5a, 0xfc, 0x90, 0x81, 0xcf, 0x81, 0xcf, 0xfa, 0x71, 0x22, 0x9a}
	binaryIDGlDeleteSamplers                                 = binary.ID{0x04, 0x52, 0x6e, 0xd2, 0xc0, 0xb4, 0xc5, 0xe3, 0xee, 0x57, 0x11, 0xb3, 0x00, 0x44, 0x78, 0xc3, 0x43, 0x0d, 0x33, 0xc9}
	binaryIDGlDeleteShader                                   = binary.ID{0x11, 0xd1, 0xa7, 0x92, 0xf4, 0x7b, 0x74, 0x2a, 0xac, 0x29, 0x4f, 0x42, 0x17, 0x9c, 0x3e, 0xb9, 0x03, 0x8d, 0xbd, 0xe7}
	binaryIDGlDeleteSync                                     = binary.ID{0x71, 0xe0, 0xcc, 0x1d, 0x4c, 0xa5, 0x2b, 0xbb, 0x7c, 0x50, 0x43, 0xa3, 0xd8, 0xce, 0x98, 0x0b, 0x82, 0xf1, 0x24, 0x91}
	binaryIDGlDeleteSyncAPPLE                                = binary.ID{0xf3, 0x5a, 0x58, 0x0f, 0xbd, 0xe8, 0x10, 0xec, 0xa0, 0xfa, 0x42, 0x87, 0x5a, 0xa2, 0x87, 0x61, 0xde, 0x88, 0x2b, 0xda}
	binaryIDTextureIdᶜᵖ                                      = binary.ID{0x90, 0x1b, 0x3e, 0xde, 0xc7, 0xbd, 0xcf, 0x9c, 0x02, 0x13, 0xc3, 0x13, 0x48, 0x1d, 0xa5, 0x17, 0xc2, 0xb3, 0x04, 0x24}
	binaryIDGlDeleteTextures                                 = binary.ID{0xd8, 0x1f, 0xfd, 0x2f, 0x01, 0xa7, 0x96, 0xe2, 0xe5, 0xe9, 0x15, 0x0a, 0xaa, 0x25, 0x1e, 0x72, 0x48, 0x13, 0x3f, 0xea}
	binaryIDTransformFeedbackIdᶜᵖ                            = binary.ID{0x55, 0x10, 0x88, 0x0c, 0x60, 0x05, 0xc1, 0x78, 0xf6, 0x69, 0xb6, 0x2c, 0x1a, 0xe0, 0xb7, 0x3c, 0xae, 0xbd, 0xed, 0xe8}
	binaryIDGlDeleteTransformFeedbacks                       = binary.ID{0x94, 0x6f, 0x65, 0xc2, 0x0c, 0x2c, 0xbe, 0x5a, 0x74, 0x4a, 0x64, 0x6d, 0x51, 0x58, 0x9f, 0xf8, 0x80, 0x02, 0x26, 0xd7}
	binaryIDVertexArrayIdᶜᵖ                                  = binary.ID{0xff, 0x46, 0x4e, 0xb5, 0x6a, 0xae, 0xa6, 0x74, 0x6e, 0x2e, 0x3c, 0x2e, 0x8b, 0x0a, 0x0d, 0xde, 0x56, 0xdd, 0x2a, 0x13}
	binaryIDGlDeleteVertexArrays                             = binary.ID{0x76, 0x64, 0xf9, 0x2d, 0x99, 0xa8, 0xdf, 0x1c, 0x1e, 0x0a, 0x2d, 0xe5, 0x98, 0xcc, 0x86, 0x28, 0x11, 0xae, 0x98, 0x33}
	binaryIDGlDeleteVertexArraysOES                          = binary.ID{0x22, 0x27, 0xfa, 0x8c, 0x76, 0xe8, 0xf5, 0xfc, 0x12, 0xbd, 0xf0, 0xa5, 0xad, 0xe8, 0x7c, 0xab, 0xe8, 0xdc, 0xb0, 0x61}
	binaryIDGlDepthFunc                                      = binary.ID{0xda, 0xba, 0x70, 0x40, 0xec, 0x50, 0xc2, 0x08, 0x20, 0x33, 0xbb, 0x87, 0x31, 0x5e, 0x01, 0x49, 0xdb, 0xf7, 0x8b, 0x60}
	binaryIDGlDepthMask                                      = binary.ID{0x97, 0x3f, 0x4a, 0x6e, 0x55, 0xfe, 0x5c, 0x75, 0x97, 0x64, 0xbc, 0x51, 0xff, 0x17, 0x83, 0xc7, 0x86, 0x81, 0xde, 0xe2}
	binaryIDGlDepthRangeArrayfvNV                            = binary.ID{0x14, 0xd6, 0x46, 0x9f, 0x02, 0x6e, 0xbc, 0xa1, 0x43, 0xeb, 0xb8, 0x7f, 0x10, 0x39, 0x01, 0x05, 0xe4, 0x78, 0x51, 0x59}
	binaryIDGlDepthRangeIndexedfNV                           = binary.ID{0x26, 0x4b, 0x47, 0xe6, 0xd5, 0x1e, 0xbd, 0xf1, 0x29, 0x6a, 0x36, 0xec, 0xca, 0x53, 0x2a, 0x6d, 0x12, 0xdf, 0x12, 0x63}
	binaryIDGlDepthRangef                                    = binary.ID{0x2e, 0x91, 0xbb, 0x94, 0xb7, 0x52, 0x60, 0xef, 0x28, 0x5f, 0x90, 0xc7, 0xd5, 0xad, 0xf3, 0xb0, 0xfb, 0x26, 0xcc, 0x48}
	binaryIDGlDetachShader                                   = binary.ID{0xd1, 0xf8, 0x03, 0x27, 0x0d, 0xc3, 0xbb, 0x7b, 0x58, 0xa8, 0x8a, 0x4d, 0x7b, 0x24, 0x57, 0xa3, 0x00, 0xcf, 0xc4, 0xce}
	binaryIDGlDisable                                        = binary.ID{0x8b, 0xbf, 0x48, 0xf5, 0x2a, 0xf6, 0x13, 0x86, 0x86, 0xfb, 0x54, 0x21, 0x35, 0x6d, 0x05, 0x45, 0x9b, 0xcb, 0x6e, 0x19}
	binaryIDGlDisableDriverControlQCOM                       = binary.ID{0x60, 0x0a, 0x65, 0x63, 0x9b, 0x16, 0x0c, 0x64, 0x1c, 0x7c, 0xda, 0xfd, 0x4c, 0x72, 0x75, 0x61, 0x75, 0x0a, 0xef, 0x8b}
	binaryIDGlDisableVertexAttribArray                       = binary.ID{0x0e, 0x71, 0x56, 0x6a, 0x0a, 0x8d, 0xc7, 0x6b, 0x76, 0x8f, 0x05, 0xca, 0xeb, 0x95, 0x01, 0x46, 0x44, 0xf6, 0xf3, 0x52}
	binaryIDGlDisableiEXT                                    = binary.ID{0xf9, 0x9b, 0xa8, 0xc9, 0x78, 0xee, 0x90, 0x5f, 0x8a, 0xe8, 0x57, 0x69, 0x42, 0xb3, 0x00, 0xb8, 0xce, 0xc7, 0x6b, 0xfb}
	binaryIDGlDisableiNV                                     = binary.ID{0xce, 0x59, 0xfe, 0x77, 0x22, 0x27, 0xbc, 0xaa, 0x82, 0x13, 0xb7, 0x31, 0x4a, 0x5c, 0xae, 0x67, 0x18, 0xba, 0x51, 0x08}
	binaryIDGlDisableiOES                                    = binary.ID{0x8a, 0x69, 0x7e, 0xd5, 0x38, 0xd2, 0x4e, 0x13, 0x55, 0x7f, 0x34, 0x01, 0xa5, 0x44, 0x98, 0x92, 0xe3, 0x1a, 0xb4, 0xfa}
	binaryIDGlDiscardFramebufferEXT                          = binary.ID{0x1f, 0x32, 0x59, 0x0d, 0xc9, 0xef, 0xe6, 0x56, 0xc5, 0x79, 0x69, 0x74, 0x4a, 0x61, 0xd0, 0x20, 0x19, 0x53, 0x62, 0x68}
	binaryIDGlDispatchCompute                                = binary.ID{0x34, 0x18, 0xc8, 0x09, 0x8f, 0x91, 0x7d, 0x44, 0x06, 0xae, 0x46, 0x8b, 0x63, 0xa3, 0xc8, 0xa5, 0x60, 0xc5, 0xb9, 0x72}
	binaryIDGlDispatchComputeIndirect                        = binary.ID{0x3b, 0x23, 0xac, 0xf8, 0x0a, 0xde, 0xd3, 0x52, 0x4f, 0x9a, 0xe1, 0x70, 0x15, 0x06, 0xb6, 0x4b, 0x67, 0xa5, 0x18, 0x2b}
	binaryIDGlDrawArrays                                     = binary.ID{0x5e, 0xa1, 0xf5, 0xa4, 0x27, 0x85, 0xd2, 0xe8, 0xbc, 0xd3, 0x16, 0x49, 0x4d, 0x5b, 0x01, 0xf0, 0x62, 0xbd, 0xf6, 0xdd}
	binaryIDGlDrawArraysIndirect                             = binary.ID{0xab, 0x8f, 0x91, 0x3e, 0x0c, 0xb5, 0x87, 0xab, 0x8d, 0x50, 0x08, 0x9b, 0x6a, 0x7e, 0x8b, 0xa6, 0xa1, 0x9b, 0x7c, 0x3b}
	binaryIDGlDrawArraysInstanced                            = binary.ID{0x6c, 0x09, 0xf8, 0x1a, 0xb7, 0x4b, 0xa4, 0x4e, 0xee, 0x89, 0xa6, 0xfa, 0x7d, 0xe5, 0x62, 0x21, 0xb1, 0xaf, 0x59, 0x8a}
	binaryIDGlDrawArraysInstancedANGLE                       = binary.ID{0xb2, 0xdf, 0x12, 0xaf, 0x14, 0x83, 0x33, 0x84, 0x1c, 0xaf, 0x73, 0xdb, 0xdd, 0x0d, 0xf2, 0xf1, 0xca, 0x22, 0x0f, 0xfc}
	binaryIDGlDrawArraysInstancedBaseInstanceEXT             = binary.ID{0xe6, 0xd6, 0x8c, 0x07, 0x49, 0x60, 0x3c, 0x43, 0x64, 0xed, 0xb4, 0x70, 0xb2, 0xb7, 0x29, 0x12, 0x37, 0x02, 0x03, 0x21}
	binaryIDGlDrawArraysInstancedEXT                         = binary.ID{0x84, 0x9b, 0x79, 0x10, 0x73, 0x08, 0x4c, 0xe5, 0x6e, 0x7e, 0x7a, 0x2a, 0xa6, 0x7f, 0xfa, 0x59, 0x87, 0x62, 0xa5, 0x25}
	binaryIDGlDrawArraysInstancedNV                          = binary.ID{0xa4, 0x19, 0x23, 0xc9, 0xe3, 0xcf, 0xd5, 0x16, 0x0b, 0xfd, 0x75, 0x66, 0x35, 0x15, 0x4f, 0x30, 0x00, 0xfb, 0xe7, 0x15}
	binaryIDGlDrawBuffers                                    = binary.ID{0x10, 0xa1, 0xf6, 0x3c, 0xe6, 0x56, 0xb2, 0x6c, 0x59, 0x9c, 0x9f, 0xab, 0x1e, 0x80, 0xf5, 0x20, 0xd0, 0x34, 0x34, 0x52}
	binaryIDGlDrawBuffersEXT                                 = binary.ID{0x52, 0xfa, 0x7f, 0xef, 0xaa, 0xc0, 0x42, 0xb4, 0xe0, 0x6c, 0xa9, 0xac, 0x2c, 0xbd, 0x28, 0xff, 0xd0, 0x0c, 0x6e, 0x18}
	binaryIDGlDrawBuffersIndexedEXT                          = binary.ID{0x3b, 0x0d, 0x4a, 0xc2, 0xfd, 0x1b, 0xf6, 0xc5, 0x75, 0xfe, 0xdc, 0xdc, 0x21, 0xb5, 0xee, 0x5e, 0x7b, 0x27, 0x8b, 0x8f}
	binaryIDGlDrawBuffersNV                                  = binary.ID{0xc6, 0x1b, 0x87, 0xe0, 0x77, 0x2c, 0xb7, 0x3d, 0x12, 0x20, 0xc1, 0xe0, 0x5a, 0xca, 0x0a, 0x1d, 0x1c, 0x3d, 0xf6, 0x68}
	binaryIDIndicesPointer                                   = binary.ID{0x7e, 0xb8, 0x8d, 0x27, 0x89, 0x30, 0x52, 0x1b, 0x7e, 0x06, 0x18, 0xa0, 0x43, 0x8e, 0x88, 0xaa, 0x0c, 0xe6, 0x72, 0x10}
	binaryIDGlDrawElements                                   = binary.ID{0xc3, 0x58, 0xa6, 0xb5, 0xe7, 0x4e, 0xbd, 0x61, 0xec, 0x16, 0x06, 0xd9, 0x56, 0x28, 0x29, 0x63, 0xd7, 0x60, 0x26, 0xe0}
	binaryIDGlDrawElementsBaseVertexEXT                      = binary.ID{0xc6, 0x01, 0x2e, 0xdc, 0x7b, 0x58, 0xf2, 0xb8, 0x08, 0x31, 0x59, 0x03, 0xe4, 0x97, 0x8b, 0x6b, 0x18, 0xe8, 0x31, 0xc7}
	binaryIDGlDrawElementsBaseVertexOES                      = binary.ID{0xbe, 0x27, 0x39, 0x73, 0xfa, 0x5b, 0xd9, 0x8b, 0x5e, 0xd7, 0x41, 0x62, 0x63, 0x34, 0xc0, 0x0a, 0x19, 0x33, 0x8a, 0x3d}
	binaryIDGlDrawElementsIndirect                           = binary.ID{0xd5, 0x00, 0xcf, 0x09, 0x73, 0x64, 0x3c, 0x94, 0x29, 0xe9, 0x2d, 0x19, 0x51, 0x2e, 0x90, 0x74, 0xd8, 0x45, 0xfa, 0x99}
	binaryIDGlDrawElementsInstanced                          = binary.ID{0x91, 0xe0, 0xbc, 0x3c, 0xfd, 0x58, 0x09, 0x0c, 0xaa, 0x9f, 0xc2, 0xe0, 0xd0, 0x66, 0xfa, 0x0c, 0x14, 0x72, 0x88, 0xa1}
	binaryIDGlDrawElementsInstancedANGLE                     = binary.ID{0x83, 0x76, 0x1f, 0xd9, 0x3f, 0xed, 0x34, 0x62, 0x16, 0xcf, 0x29, 0x29, 0x19, 0x3c, 0x6c, 0xe3, 0x6c, 0xd3, 0x26, 0xc2}
	binaryIDGlDrawElementsInstancedBaseInstanceEXT           = binary.ID{0x3d, 0xde, 0x19, 0x3a, 0xb5, 0x36, 0x1b, 0x45, 0x80, 0x89, 0xdc, 0x02, 0x58, 0x66, 0xcf, 0x60, 0x51, 0x5b, 0xb7, 0xb6}
	binaryIDGlDrawElementsInstancedBaseVertexBaseInstanceEXT = binary.ID{0x5b, 0xfd, 0x0a, 0x10, 0x30, 0x0e, 0xb7, 0x0e, 0xbd, 0xdd, 0x9f, 0x38, 0x86, 0xb0, 0xf4, 0xd2, 0x45, 0x92, 0x56, 0xed}
	binaryIDGlDrawElementsInstancedBaseVertexEXT             = binary.ID{0xba, 0xd4, 0x6d, 0x5d, 0xf5, 0x36, 0xe1, 0xe1, 0xd8, 0x3c, 0x37, 0x9b, 0x3c, 0xc0, 0x0a, 0xc5, 0x9b, 0x2d, 0x3f, 0x37}
	binaryIDGlDrawElementsInstancedBaseVertexOES             = binary.ID{0x12, 0xc0, 0xab, 0x32, 0x0e, 0xae, 0x13, 0x66, 0xd8, 0xfc, 0x60, 0x52, 0xbc, 0x4c, 0x9e, 0x27, 0xd3, 0xc9, 0x08, 0xc1}
	binaryIDGlDrawElementsInstancedEXT                       = binary.ID{0x0d, 0x88, 0x26, 0x49, 0xf0, 0x60, 0x4e, 0xb6, 0x87, 0xe0, 0x20, 0xff, 0x37, 0xf7, 0x5e, 0x1c, 0xcc, 0x64, 0xd8, 0x79}
	binaryIDGlDrawElementsInstancedNV                        = binary.ID{0x93, 0xc6, 0x5d, 0xbb, 0x00, 0x86, 0xef, 0x5b, 0x74, 0xd3, 0xaf, 0xb0, 0xd0, 0x0b, 0x5d, 0x39, 0x3e, 0x12, 0x83, 0x46}
	binaryIDGlDrawRangeElements                              = binary.ID{0xd9, 0x92, 0x7c, 0x94, 0x49, 0xdf, 0x20, 0x5c, 0x2f, 0xc4, 0x45, 0x7f, 0x52, 0xaf, 0x90, 0xc6, 0xc6, 0xf3, 0x05, 0xfc}
	binaryIDGlDrawRangeElementsBaseVertexEXT                 = binary.ID{0x92, 0x94, 0x02, 0xd3, 0x32, 0xb2, 0x99, 0xa2, 0x4a, 0xff, 0x98, 0x22, 0x13, 0xc7, 0x03, 0x86, 0x09, 0xed, 0x4e, 0xb2}
	binaryIDGlDrawRangeElementsBaseVertexOES                 = binary.ID{0x7c, 0xf8, 0x8a, 0x03, 0x92, 0x54, 0x07, 0xb7, 0x9f, 0xd7, 0x4a, 0x4e, 0x8a, 0x4a, 0xeb, 0xe6, 0x85, 0x22, 0xe5, 0xdb}
	binaryIDGlEGLImageTargetRenderbufferStorageOES           = binary.ID{0x9e, 0xae, 0xc5, 0x0e, 0x81, 0x91, 0x4d, 0x5f, 0xf3, 0x64, 0xf6, 0x07, 0xea, 0x99, 0x07, 0x09, 0x76, 0x25, 0xd8, 0x7f}
	binaryIDGlEGLImageTargetTexture2DOES                     = binary.ID{0x8a, 0x74, 0x5e, 0x16, 0xf2, 0x1a, 0x7c, 0x44, 0x37, 0x63, 0x10, 0x12, 0xb9, 0x30, 0x4f, 0x6d, 0x07, 0x4f, 0xb8, 0xb0}
	binaryIDGlEnable                                         = binary.ID{0xa2, 0x43, 0xf9, 0xb3, 0x0e, 0xf8, 0x8b, 0x33, 0x2b, 0xc0, 0x38, 0x39, 0x72, 0x7b, 0x53, 0xcb, 0xf0, 0x38, 0x29, 0x01}
	binaryIDGlEnableDriverControlQCOM                        = binary.ID{0x8a, 0xfa, 0xb1, 0x22, 0x3a, 0x84, 0x67, 0xb9, 0xaf, 0x96, 0xde, 0x31, 0x57, 0x27, 0xdb, 0x08, 0xd1, 0xeb, 0x05, 0xd7}
	binaryIDGlEnableVertexAttribArray                        = binary.ID{0xe7, 0x92, 0xb4, 0x99, 0xeb, 0x7e, 0xdc, 0x7a, 0xbb, 0x5b, 0x49, 0x71, 0x82, 0xd3, 0x09, 0x49, 0xb4, 0x0f, 0xfc, 0x66}
	binaryIDGlEnableiEXT                                     = binary.ID{0x93, 0xe0, 0xa4, 0xe9, 0xfe, 0xe1, 0x87, 0x69, 0xe9, 0x9a, 0xd9, 0x0b, 0xca, 0x9c, 0x67, 0xcd, 0x68, 0x23, 0x4c, 0x85}
	binaryIDGlEnableiNV                                      = binary.ID{0xfb, 0xeb, 0x11, 0x7c, 0xb8, 0xc3, 0x5d, 0x38, 0xb0, 0x69, 0xf4, 0xea, 0x7f, 0xb6, 0x40, 0x5f, 0x0f, 0x4b, 0x7b, 0xbb}
	binaryIDGlEnableiOES                                     = binary.ID{0x57, 0x86, 0x34, 0x07, 0x41, 0x9a, 0xd4, 0x1c, 0x1b, 0x0c, 0xf4, 0x22, 0x02, 0x00, 0xa3, 0xfe, 0x09, 0x6b, 0x0f, 0x5c}
	binaryIDGlEndConditionalRenderNV                         = binary.ID{0x17, 0x91, 0x80, 0x10, 0x83, 0x1d, 0x8e, 0x01, 0x77, 0xe5, 0x68, 0x6d, 0xf7, 0x90, 0x02, 0x4f, 0x4f, 0x70, 0x2e, 0xb4}
	binaryIDGlEndPerfMonitorAMD                              = binary.ID{0x16, 0xe5, 0xfd, 0x91, 0xab, 0x66, 0x7a, 0x2d, 0x72, 0xad, 0x1e, 0xb0, 0x93, 0xba, 0xdf, 0x4d, 0x77, 0x2e, 0xa1, 0x88}
	binaryIDGlEndPerfQueryINTEL                              = binary.ID{0xf0, 0x7d, 0x6b, 0x0b, 0x87, 0x6f, 0x5f, 0x5f, 0xd1, 0x9f, 0xf0, 0xbf, 0x78, 0xfc, 0x41, 0x90, 0x10, 0x21, 0x8c, 0xf5}
	binaryIDGlEndQuery                                       = binary.ID{0x99, 0x4c, 0x6c, 0x09, 0x13, 0xed, 0x42, 0x85, 0x32, 0x5d, 0xea, 0x47, 0x1c, 0xb5, 0xbf, 0x7f, 0x8c, 0xc5, 0x8b, 0xc9}
	binaryIDGlEndQueryEXT                                    = binary.ID{0x7e, 0x0b, 0x88, 0x53, 0xd1, 0x82, 0xd9, 0xa6, 0x6d, 0xb0, 0x06, 0x93, 0x5a, 0x35, 0x78, 0x08, 0xb3, 0xf2, 0xa5, 0x4f}
	binaryIDGlEndTilingQCOM                                  = binary.ID{0x7a, 0x5f, 0xdc, 0x25, 0xf8, 0x3d, 0x05, 0xaf, 0x8f, 0x7b, 0x62, 0xbd, 0x13, 0x0f, 0x28, 0x9f, 0xf8, 0xfc, 0x05, 0x3f}
	binaryIDGlEndTransformFeedback                           = binary.ID{0xb6, 0xbb, 0x1a, 0x1b, 0xe2, 0x6a, 0xaa, 0x42, 0xfa, 0xbe, 0x76, 0xbb, 0x4d, 0x2a, 0xce, 0xdd, 0xc5, 0x08, 0x4e, 0x5f}
	binaryIDVoidᵖᵖ                                           = binary.ID{0x40, 0xea, 0xad, 0xfd, 0xbc, 0xf5, 0x14, 0x91, 0x13, 0x77, 0x82, 0x2d, 0x30, 0x61, 0xae, 0x40, 0xda, 0x64, 0xd7, 0x18}
	binaryIDGlExtGetBufferPointervQCOM                       = binary.ID{0xd1, 0xcb, 0xc6, 0xcf, 0x90, 0x4a, 0xff, 0x63, 0x37, 0xb3, 0xab, 0xb1, 0x49, 0x28, 0xb1, 0x3d, 0x8c, 0x40, 0xa7, 0x66}
	binaryIDGlExtGetBuffersQCOM                              = binary.ID{0x3c, 0x76, 0xf3, 0x36, 0xfc, 0xce, 0xa2, 0xb5, 0xa8, 0xa3, 0x8b, 0x29, 0x41, 0xc3, 0xd0, 0x29, 0xc2, 0x2e, 0xdc, 0xb3}
	binaryIDGlExtGetFramebuffersQCOM                         = binary.ID{0xba, 0x52, 0xa2, 0x8f, 0x19, 0xd8, 0x78, 0x81, 0xc7, 0x45, 0x0d, 0x87, 0xbf, 0x02, 0xb1, 0x8a, 0x2c, 0xea, 0x2d, 0x40}
	binaryIDGlExtGetProgramBinarySourceQCOM                  = binary.ID{0xe2, 0x2d, 0x72, 0x30, 0xd3, 0xef, 0xa3, 0x5d, 0x27, 0x01, 0x00, 0xe1, 0x06, 0x80, 0xd0, 0x39, 0xdb, 0x7a, 0x74, 0x49}
	binaryIDProgramIdᵖ                                       = binary.ID{0x35, 0x8e, 0x6d, 0x06, 0x42, 0xe3, 0x05, 0xaf, 0xe7, 0xb6, 0xd7, 0x90, 0x61, 0xe0, 0x8a, 0xdd, 0x4f, 0x3e, 0xf7, 0x69}
	binaryIDGlExtGetProgramsQCOM                             = binary.ID{0x2d, 0xdb, 0xc8, 0x9d, 0xdd, 0x08, 0xdc, 0x6b, 0xd3, 0x07, 0x29, 0xe6, 0xa4, 0xb8, 0x19, 0x51, 0x30, 0xfc, 0x78, 0xe4}
	binaryIDRenderbufferIdᵖ                                  = binary.ID{0x27, 0x87, 0x17, 0xca, 0xd8, 0x49, 0x08, 0x71, 0xe9, 0xc6, 0x9c, 0x0e, 0x51, 0x5a, 0x23, 0x8c, 0xc5, 0x2a, 0xdd, 0x2e}
	binaryIDGlExtGetRenderbuffersQCOM                        = binary.ID{0x42, 0x36, 0x42, 0x88, 0xfa, 0xfc, 0xc0, 0x25, 0x38, 0x9c, 0x15, 0xc9, 0x58, 0xb2, 0x62, 0xc9, 0xf6, 0xf0, 0x05, 0xdf}
	binaryIDShaderIdᵖ                                        = binary.ID{0x08, 0x71, 0x0c, 0xb0, 0x87, 0xa9, 0x21, 0x1b, 0xe0, 0x32, 0x0c, 0x9f, 0x24, 0xe3, 0xfb, 0x8e, 0xd5, 0x60, 0x80, 0x1d}
	binaryIDGlExtGetShadersQCOM                              = binary.ID{0x63, 0x0a, 0xb7, 0x2f, 0xb4, 0x6e, 0xe9, 0x59, 0x2a, 0xa6, 0xc0, 0xee, 0x6f, 0x46, 0xdd, 0xc4, 0x19, 0x87, 0xae, 0xe6}
	binaryIDGlExtGetTexLevelParameterivQCOM                  = binary.ID{0x81, 0xd8, 0xa1, 0x14, 0x14, 0x87, 0x4c, 0x50, 0x30, 0x3c, 0xdf, 0xce, 0xa1, 0x83, 0x90, 0x09, 0x1c, 0xeb, 0xe3, 0x3c}
	binaryIDGlExtGetTexSubImageQCOM                          = binary.ID{0x04, 0xa4, 0x94, 0xc6, 0xe5, 0x42, 0x94, 0x41, 0xb4, 0x3d, 0x21, 0xa0, 0x6e, 0xfb, 0xc6, 0x19, 0xf5, 0xcf, 0x20, 0x6c}
	binaryIDTextureIdᵖ                                       = binary.ID{0x6c, 0x3c, 0x90, 0x11, 0x71, 0x98, 0x36, 0xdd, 0xc8, 0x9c, 0x08, 0xf7, 0x80, 0x31, 0x56, 0x36, 0x6e, 0xd7, 0x68, 0x6b}
	binaryIDGlExtGetTexturesQCOM                             = binary.ID{0x41, 0x5e, 0xe0, 0x48, 0xf4, 0x23, 0x46, 0xbf, 0xcb, 0x1d, 0x72, 0xd1, 0x4e, 0xd0, 0x55, 0x36, 0x8b, 0xca, 0xf1, 0xeb}
	binaryIDGlExtIsProgramBinaryQCOM                         = binary.ID{0xad, 0xb8, 0x6a, 0xb0, 0x73, 0xbf, 0xec, 0xba, 0xab, 0xb1, 0x22, 0x89, 0x65, 0x05, 0xea, 0x4d, 0xf2, 0xd4, 0xba, 0xc9}
	binaryIDGlExtTexObjectStateOverrideiQCOM                 = binary.ID{0x9b, 0xad, 0xf7, 0x17, 0x7f, 0x2c, 0x20, 0xe8, 0xbd, 0x61, 0x09, 0x14, 0xfd, 0xb8, 0xd4, 0xd3, 0xf5, 0xb4, 0x6d, 0xc0}
	binaryIDGlFenceSync                                      = binary.ID{0xa3, 0x54, 0xc6, 0x3c, 0x5f, 0xa4, 0x96, 0xfb, 0xe6, 0x6f, 0x30, 0x53, 0x0f, 0xed, 0x02, 0x36, 0xa0, 0x76, 0x30, 0xbf}
	binaryIDGlFenceSyncAPPLE                                 = binary.ID{0xf9, 0x2c, 0x1a, 0x0d, 0x67, 0x37, 0x5a, 0x73, 0xb4, 0x07, 0xd3, 0x7a, 0x79, 0x49, 0x25, 0xf8, 0x76, 0x79, 0x92, 0x48}
	binaryIDGlFinish                                         = binary.ID{0x62, 0xe9, 0xca, 0xf4, 0x39, 0xd8, 0x39, 0x1e, 0x49, 0x43, 0x1f, 0x40, 0xbb, 0x3d, 0x1b, 0x11, 0xc9, 0x5c, 0x9a, 0xf9}
	binaryIDGlFinishFenceNV                                  = binary.ID{0xee, 0xf3, 0xbc, 0xb6, 0x47, 0xdc, 0x40, 0x51, 0xe6, 0xd4, 0x49, 0x97, 0xe8, 0x37, 0x8b, 0xf2, 0x8b, 0x12, 0x38, 0xed}
	binaryIDGlFlush                                          = binary.ID{0x63, 0x83, 0x26, 0x9a, 0x10, 0x6b, 0x68, 0x9f, 0x90, 0x65, 0x54, 0xba, 0x66, 0x25, 0xc8, 0x09, 0x24, 0xe3, 0x21, 0x00}
	binaryIDGlFlushMappedBufferRange                         = binary.ID{0xd1, 0x85, 0x86, 0x1b, 0x3a, 0x9f, 0x3b, 0x82, 0x3a, 0xda, 0x16, 0x19, 0xb8, 0xc7, 0x75, 0x3a, 0x30, 0xec, 0x4d, 0x4b}
	binaryIDGlFlushMappedBufferRangeEXT                      = binary.ID{0x80, 0x99, 0x39, 0xc6, 0x0f, 0x91, 0xc1, 0x91, 0x33, 0x10, 0x7c, 0x6e, 0xf1, 0x6d, 0xb6, 0x53, 0x2a, 0x14, 0xe6, 0x59}
	binaryIDGlFragmentCoverageColorNV                        = binary.ID{0x03, 0x80, 0x67, 0xc1, 0xf2, 0x00, 0xab, 0x54, 0x2a, 0xee, 0x86, 0xf5, 0xe3, 0xb3, 0xe6, 0xb1, 0x89, 0x13, 0x58, 0x77}
	binaryIDGlFramebufferParameteri                          = binary.ID{0xb8, 0x00, 0xd9, 0xfc, 0xf7, 0x85, 0x00, 0xe5, 0xc6, 0x1e, 0x6e, 0xa3, 0xfb, 0x79, 0x8e, 0xb5, 0xf6, 0x18, 0x68, 0x0c}
	binaryIDGlFramebufferRenderbuffer                        = binary.ID{0x84, 0x49, 0x2e, 0xdd, 0x19, 0x60, 0xcf, 0xf5, 0x05, 0xce, 0xd4, 0xf8, 0x5e, 0x70, 0x38, 0x4e, 0xdb, 0x6f, 0xf4, 0x46}
	binaryIDGlFramebufferSampleLocationsfvNV                 = binary.ID{0x7e, 0xc8, 0xb1, 0x2f, 0xc4, 0x0a, 0x65, 0xd6, 0x97, 0xd5, 0xb5, 0x31, 0x32, 0xf5, 0x15, 0x5b, 0x3a, 0x90, 0x7d, 0xca}
	binaryIDGlFramebufferTexture2D                           = binary.ID{0x66, 0xf3, 0xec, 0x3c, 0xa3, 0xb6, 0x49, 0xba, 0x0f, 0xed, 0xc9, 0x1d, 0x71, 0x63, 0x38, 0x2b, 0xb2, 0x50, 0xf9, 0x8a}
	binaryIDGlFramebufferTexture2DMultisampleEXT             = binary.ID{0x63, 0x22, 0xc0, 0xa0, 0xfd, 0xf4, 0xd7, 0x15, 0x62, 0x37, 0xcb, 0x14, 0x21, 0x6b, 0x89, 0xc8, 0xc5, 0xad, 0x8f, 0xc0}
	binaryIDGlFramebufferTexture2DMultisampleIMG             = binary.ID{0x34, 0xf9, 0xf0, 0xc2, 0x46, 0xa4, 0x29, 0xdb, 0xa7, 0xcf, 0x32, 0x55, 0xed, 0x06, 0xed, 0xff, 0xd3, 0x55, 0x7a, 0x88}
	binaryIDGlFramebufferTexture3DOES                        = binary.ID{0xe0, 0x12, 0x88, 0xde, 0x85, 0x6e, 0x6e, 0xed, 0x90, 0x21, 0x81, 0xde, 0xda, 0x23, 0xc9, 0x29, 0xf8, 0xb1, 0x6d, 0xf8}
	binaryIDGlFramebufferTextureEXT                          = binary.ID{0x84, 0x45, 0x0b, 0xad, 0xa3, 0xb5, 0xc3, 0x98, 0x45, 0x3e, 0xfb, 0x2e, 0x4b, 0xed, 0x43, 0x16, 0x97, 0x46, 0x7b, 0x7e}
	binaryIDGlFramebufferTextureLayer                        = binary.ID{0x97, 0x32, 0x08, 0xc5, 0xdc, 0x72, 0x24, 0x5b, 0x12, 0x58, 0xf5, 0xef, 0x18, 0x3e, 0x72, 0x67, 0x83, 0x55, 0xdd, 0x3a}
	binaryIDGlFramebufferTextureMultiviewOVR                 = binary.ID{0x3b, 0x34, 0xac, 0xce, 0x01, 0x26, 0xb3, 0x42, 0x0d, 0x1f, 0xb9, 0x5f, 0x45, 0xcf, 0x3f, 0x7a, 0x57, 0x0c, 0x3b, 0xb9}
	binaryIDGlFramebufferTextureOES                          = binary.ID{0xf6, 0xd5, 0xf4, 0x01, 0xac, 0xc8, 0x70, 0x76, 0x7b, 0x20, 0x33, 0x56, 0xc4, 0x63, 0x45, 0x70, 0xa7, 0xe1, 0xa6, 0x23}
	binaryIDGlFrontFace                                      = binary.ID{0x6c, 0xf1, 0xae, 0xbd, 0xd4, 0xb5, 0x64, 0xcb, 0xea, 0x37, 0x0e, 0x83, 0x70, 0xe1, 0x0b, 0xe1, 0x88, 0x7e, 0x76, 0xe6}
	binaryIDGlGenBuffers                                     = binary.ID{0xff, 0x05, 0xbb, 0xb1, 0x4c, 0x23, 0x10, 0x3c, 0x62, 0xbb, 0xab, 0x4e, 0x96, 0x97, 0xee, 0x65, 0xac, 0x91, 0x10, 0xe1}
	binaryIDGlGenFencesNV                                    = binary.ID{0xc4, 0xcc, 0xec, 0x1f, 0xe6, 0x04, 0x76, 0x03, 0x87, 0xa8, 0x5a, 0x60, 0x88, 0x38, 0x06, 0xfd, 0x25, 0x44, 0x07, 0xe7}
	binaryIDGlGenFramebuffers                                = binary.ID{0x1f, 0x78, 0x9b, 0xf0, 0x2f, 0x80, 0x32, 0xf2, 0x0d, 0x1b, 0x62, 0x3e, 0x54, 0x81, 0x6f, 0xe5, 0x0b, 0x20, 0xc2, 0x36}
	binaryIDGlGenPathsNV                                     = binary.ID{0xc2, 0x7e, 0xe7, 0xa4, 0xa8, 0x73, 0x1a, 0xa1, 0x9f, 0x1b, 0x6b, 0xb0, 0x5a, 0x3a, 0xa2, 0x9b, 0x78, 0x29, 0x77, 0x28}
	binaryIDGlGenPerfMonitorsAMD                             = binary.ID{0xbb, 0x43, 0x30, 0xe0, 0xf7, 0xb6, 0xb1, 0x8f, 0x9a, 0xb1, 0xf5, 0xdd, 0x4d, 0xbb, 0x1d, 0x4b, 0x22, 0x9c, 0xcf, 0x44}
	binaryIDPipelineIdᵖ                                      = binary.ID{0x42, 0x03, 0x28, 0x19, 0xc1, 0xbe, 0x2b, 0x3e, 0x95, 0x3d, 0x58, 0x23, 0xfd, 0xea, 0xae, 0x78, 0xbd, 0x59, 0xa7, 0xdd}
	binaryIDGlGenProgramPipelines                            = binary.ID{0x10, 0xe9, 0xbb, 0xb8, 0xd8, 0x40, 0x2f, 0x84, 0x42, 0xad, 0x9d, 0xba, 0xb0, 0x90, 0x73, 0xf2, 0x47, 0x24, 0x9c, 0x1c}
	binaryIDGlGenProgramPipelinesEXT                         = binary.ID{0x8f, 0x7e, 0x53, 0x65, 0xbb, 0xd2, 0x7d, 0xd5, 0xd5, 0x96, 0xe6, 0x19, 0x66, 0x36, 0x9a, 0x9d, 0x1c, 0xdb, 0x02, 0x14}
	binaryIDQueryIdᵖ                                         = binary.ID{0xeb, 0x17, 0x82, 0xad, 0x2a, 0x8d, 0x90, 0x53, 0x42, 0x82, 0x61, 0x49, 0x70, 0xb2, 0xde, 0x5e, 0x4a, 0xce, 0x10, 0x9a}
	binaryIDGlGenQueries                                     = binary.ID{0x13, 0x8a, 0x2b, 0xf9, 0x21, 0x4c, 0x41, 0x0d, 0xb4, 0x5e, 0x55, 0x88, 0x63, 0x09, 0xef, 0x98, 0x8a, 0x9d, 0x84, 0x9d}
	binaryIDGlGenQueriesEXT                                  = binary.ID{0x3d, 0x5c, 0x2f, 0xec, 0x6a, 0xfb, 0x83, 0x68, 0x6e, 0xe6, 0x86, 0xd1, 0xa6, 0x73, 0xd3, 0x4b, 0xfa, 0x89, 0xfd, 0x14}
	binaryIDGlGenRenderbuffers                               = binary.ID{0xc4, 0x12, 0x5c, 0xd5, 0xc7, 0x63, 0x5c, 0xa2, 0x8d, 0xe8, 0xac, 0xbe, 0xdf, 0xa8, 0x69, 0xdb, 0xdf, 0xf1, 0xf5, 0xbd}
	binaryIDSamplerIdᵖ                                       = binary.ID{0x3e, 0x74, 0x4b, 0x8d, 0x90, 0xb4, 0x9d, 0x42, 0xd2, 0x00, 0x43, 0xfd, 0x05, 0x10, 0x42, 0x39, 0xad, 0x95, 0xc8, 0xff}
	binaryIDGlGenSamplers                                    = binary.ID{0x53, 0x8f, 0xa9, 0x76, 0xca, 0x95, 0x90, 0x0b, 0x3c, 0x11, 0xcc, 0x52, 0x89, 0x88, 0x2d, 0x14, 0xfb, 0x5e, 0x70, 0x01}
	binaryIDGlGenTextures                                    = binary.ID{0xf5, 0x84, 0xb5, 0xa7, 0xc8, 0xb4, 0x4c, 0xbb, 0x8d, 0x6a, 0x19, 0xed, 0xc8, 0xef, 0x95, 0xfb, 0x65, 0x1d, 0xe1, 0xc9}
	binaryIDTransformFeedbackIdᵖ                             = binary.ID{0x42, 0x9d, 0xec, 0xfb, 0x96, 0x87, 0xa9, 0xe5, 0x68, 0xdd, 0x36, 0xb5, 0x00, 0x56, 0x81, 0xf7, 0x2b, 0x4f, 0xe6, 0xf3}
	binaryIDGlGenTransformFeedbacks                          = binary.ID{0x54, 0xc2, 0x34, 0x23, 0x7b, 0x3e, 0x7e, 0x0f, 0x64, 0x80, 0x66, 0xbc, 0x92, 0x0e, 0xcf, 0xe0, 0x54, 0x1b, 0x9a, 0xca}
	binaryIDVertexArrayIdᵖ                                   = binary.ID{0x06, 0x33, 0x83, 0xad, 0xcf, 0x1c, 0x8f, 0x00, 0x5d, 0x52, 0x0a, 0xc4, 0x29, 0xca, 0xe3, 0x06, 0x6a, 0x5e, 0x71, 0x5f}
	binaryIDGlGenVertexArrays                                = binary.ID{0x17, 0x72, 0xaf, 0x31, 0x1b, 0xab, 0x7c, 0xa0, 0x81, 0xd5, 0xa4, 0xbb, 0x41, 0xe5, 0x02, 0xd8, 0x14, 0x45, 0x34, 0x4b}
	binaryIDGlGenVertexArraysOES                             = binary.ID{0xe4, 0x81, 0x31, 0xf5, 0x7b, 0xe5, 0xd8, 0x53, 0x9c, 0x04, 0xc0, 0x55, 0xfe, 0x8f, 0x4c, 0x35, 0xdb, 0x02, 0xe4, 0x68}
	binaryIDGlGenerateMipmap                                 = binary.ID{0x57, 0x53, 0x3c, 0x04, 0x55, 0x37, 0x78, 0xfa, 0x25, 0x8d, 0x25, 0x02, 0xde, 0x9c, 0x0c, 0xaf, 0x9a, 0xd8, 0x38, 0x31}
	binaryIDGlGetActiveAttrib                                = binary.ID{0x14, 0x7b, 0x7d, 0x4a, 0xf1, 0x38, 0xea, 0x55, 0x61, 0x75, 0x79, 0x35, 0x4a, 0x80, 0x8f, 0x69, 0xc5, 0x05, 0x62, 0x54}
	binaryIDGlGetActiveUniform                               = binary.ID{0xe4, 0x5e, 0x05, 0xbd, 0xf5, 0xa1, 0x8d, 0x2c, 0x8c, 0xb9, 0x58, 0xf7, 0x52, 0xa4, 0x38, 0x1d, 0x83, 0x18, 0xa1, 0xff}
	binaryIDGlGetActiveUniformBlockName                      = binary.ID{0x85, 0x05, 0x73, 0x0d, 0x80, 0xc8, 0x3e, 0xda, 0xb0, 0xbc, 0x1e, 0xea, 0x2a, 0xb6, 0x6d, 0xe5, 0xb9, 0x19, 0x53, 0x2d}
	binaryIDGlGetActiveUniformBlockiv                        = binary.ID{0x70, 0x1a, 0x53, 0x8b, 0x1a, 0x5b, 0xeb, 0xf2, 0x36, 0x6f, 0xd8, 0xcb, 0xce, 0x92, 0x52, 0x74, 0xe2, 0x16, 0x13, 0xdb}
	binaryIDGlGetActiveUniformsiv                            = binary.ID{0x58, 0x47, 0x7e, 0x47, 0xb2, 0xaa, 0x8b, 0xfd, 0x75, 0x9b, 0x02, 0xd9, 0x54, 0x53, 0x48, 0x9e, 0xc2, 0xf3, 0xe0, 0x7e}
	binaryIDGlGetAttachedShaders                             = binary.ID{0x50, 0x20, 0x01, 0x35, 0xf4, 0x86, 0x57, 0xab, 0xd6, 0x53, 0x6f, 0x7c, 0x7f, 0x84, 0xcb, 0x83, 0x7f, 0x43, 0xf5, 0x04}
	binaryIDGlGetAttribLocation                              = binary.ID{0x75, 0xe9, 0x55, 0x96, 0x01, 0x85, 0x1d, 0xe7, 0xa7, 0xe9, 0xef, 0x2b, 0xd9, 0x77, 0x06, 0x8f, 0xe8, 0xd1, 0xce, 0x85}
	binaryIDGlGetBooleani_v                                  = binary.ID{0xbe, 0x62, 0xf1, 0x22, 0xe9, 0x23, 0x5a, 0x62, 0x6d, 0x83, 0xf4, 0xa2, 0x9b, 0x26, 0x67, 0xf0, 0xff, 0x5b, 0x49, 0x36}
	binaryIDGlGetBooleanv                                    = binary.ID{0xb2, 0x87, 0x76, 0x95, 0xc0, 0xf9, 0xcf, 0x8f, 0x96, 0xf2, 0x88, 0x6c, 0xe2, 0x42, 0xae, 0x98, 0x8b, 0x78, 0x63, 0xfb}
	binaryIDGlGetBufferParameteri64v                         = binary.ID{0x78, 0xf8, 0xa3, 0xa0, 0xe0, 0x61, 0x42, 0x73, 0x31, 0xfe, 0x9f, 0x5f, 0xe0, 0xe9, 0x27, 0xcb, 0x91, 0xbd, 0x10, 0xb3}
	binaryIDGlGetBufferParameteriv                           = binary.ID{0xcb, 0x07, 0x1f, 0x27, 0x1d, 0x18, 0xbe, 0xcf, 0x2e, 0xb3, 0x4c, 0x5d, 0x9b, 0x3d, 0x6b, 0xa9, 0xfa, 0xe9, 0x80, 0x54}
	binaryIDGlGetBufferPointerv                              = binary.ID{0xa3, 0x3f, 0x91, 0xab, 0xed, 0x6d, 0x34, 0xb9, 0x97, 0xb3, 0xcd, 0x76, 0xbd, 0x24, 0x18, 0x2f, 0xeb, 0x6b, 0xcc, 0x42}
	binaryIDGlGetBufferPointervOES                           = binary.ID{0x84, 0x51, 0x92, 0x9d, 0x1d, 0xa4, 0xbe, 0x64, 0x41, 0x2f, 0xc1, 0x60, 0x5d, 0x8e, 0xe1, 0xa0, 0xe7, 0xf3, 0x1a, 0x36}
	binaryIDGlGetCoverageModulationTableNV                   = binary.ID{0xb6, 0xb3, 0x8f, 0x1c, 0x55, 0x33, 0x73, 0x67, 0x92, 0x79, 0xc6, 0x6f, 0x5d, 0x07, 0xc3, 0x74, 0x7f, 0x3b, 0xec, 0xab}
	binaryIDGlGetDebugMessageLogKHR                          = binary.ID{0xc5, 0x43, 0xda, 0xf0, 0x66, 0xec, 0xe4, 0x25, 0xde, 0x85, 0x16, 0x13, 0xb8, 0xc1, 0x69, 0x7c, 0x35, 0xc9, 0x2e, 0x13}
	binaryIDGlGetDriverControlStringQCOM                     = binary.ID{0xce, 0xe6, 0x63, 0xc6, 0x0a, 0xbc, 0x22, 0x2d, 0xaa, 0xd6, 0xdb, 0xba, 0x4a, 0x24, 0xe1, 0x48, 0xb7, 0x36, 0x94, 0x5b}
	binaryIDGlGetDriverControlsQCOM                          = binary.ID{0x0e, 0xcc, 0x1b, 0x68, 0xf8, 0xdd, 0xa4, 0x1a, 0xac, 0xad, 0xe0, 0x80, 0x18, 0xe9, 0x5f, 0xe9, 0xd2, 0x88, 0x59, 0xa5}
	binaryIDGlGetError                                       = binary.ID{0x1e, 0x4f, 0x5f, 0x38, 0x56, 0xec, 0xc9, 0x35, 0x5b, 0xfb, 0xb0, 0x61, 0x09, 0xfa, 0x63, 0x69, 0xe0, 0x7a, 0x2a, 0x8c}
	binaryIDGlGetFenceivNV                                   = binary.ID{0x70, 0xf3, 0x81, 0x55, 0xf7, 0x91, 0x49, 0x98, 0xdf, 0x79, 0x5c, 0x26, 0x01, 0x0a, 0x77, 0x0a, 0xc1, 0x71, 0x9f, 0xa2}
	binaryIDGlGetFirstPerfQueryIdINTEL                       = binary.ID{0x8c, 0x0a, 0xf0, 0x07, 0x36, 0x36, 0xa9, 0xa0, 0x66, 0xa4, 0x03, 0x13, 0xc1, 0x98, 0x59, 0xa9, 0x88, 0x62, 0x7d, 0xac}
	binaryIDGlGetFloati_vNV                                  = binary.ID{0x74, 0x0d, 0xb3, 0x0a, 0x9b, 0x26, 0x5b, 0xea, 0x0a, 0xb1, 0x3e, 0xd5, 0xd7, 0xdb, 0x8d, 0xea, 0xea, 0xf6, 0x98, 0x30}
	binaryIDGlGetFloatv                                      = binary.ID{0x94, 0x62, 0x23, 0x02, 0x41, 0xc5, 0x0a, 0xdd, 0x50, 0x4b, 0x7a, 0x25, 0x66, 0x61, 0x71, 0xfe, 0x57, 0xe9, 0x49, 0x51}
	binaryIDGlGetFragDataLocation                            = binary.ID{0x69, 0x78, 0xe9, 0xa0, 0x6b, 0x1f, 0xcf, 0xdf, 0x50, 0x07, 0x01, 0xbf, 0x0a, 0x94, 0xa7, 0x06, 0x8f, 0x01, 0x3e, 0x60}
	binaryIDGlGetFramebufferAttachmentParameteriv            = binary.ID{0x36, 0x48, 0xc4, 0xc9, 0x4f, 0x83, 0xb0, 0xad, 0xc9, 0x09, 0x01, 0xbd, 0x2f, 0x6c, 0x4b, 0x1b, 0x31, 0x03, 0xa4, 0xe5}
	binaryIDGlGetFramebufferParameteriv                      = binary.ID{0xcb, 0xf7, 0x76, 0xe9, 0x4e, 0xd2, 0x1e, 0x5f, 0x91, 0xf0, 0xf1, 0xb1, 0xb5, 0xa7, 0xd2, 0xc6, 0x1d, 0x52, 0x99, 0x19}
	binaryIDGlGetGraphicsResetStatusEXT                      = binary.ID{0x8d, 0x3f, 0x9e, 0x9d, 0x27, 0xd7, 0x66, 0xad, 0x95, 0x1f, 0xf9, 0x73, 0x27, 0xd8, 0x87, 0x5b, 0x64, 0xba, 0xc5, 0xb7}
	binaryIDGlGetGraphicsResetStatusKHR                      = binary.ID{0xc0, 0x8b, 0x35, 0xb6, 0x03, 0x19, 0xe0, 0x58, 0xa0, 0x18, 0x9c, 0x30, 0x8c, 0x28, 0xb8, 0x43, 0x1a, 0x24, 0xa7, 0x99}
	binaryIDGlGetImageHandleNV                               = binary.ID{0xf3, 0x04, 0x85, 0x85, 0xa8, 0xcd, 0xfe, 0x4c, 0x30, 0xd8, 0xd4, 0xb5, 0x55, 0xe3, 0x4c, 0x5d, 0x85, 0xb6, 0x34, 0xb6}
	binaryIDGlGetInteger64i_v                                = binary.ID{0xa4, 0x2f, 0xa5, 0x68, 0xe0, 0xef, 0xa9, 0x08, 0xfc, 0x9b, 0xaf, 0x2e, 0x72, 0xde, 0xfe, 0xdf, 0x23, 0xc7, 0x4a, 0xdc}
	binaryIDGlGetInteger64v                                  = binary.ID{0x9f, 0xda, 0xb9, 0x00, 0x1a, 0xfa, 0x37, 0xab, 0xde, 0x4a, 0xe4, 0x80, 0x1f, 0x40, 0xd7, 0x3b, 0xf7, 0xba, 0xbe, 0x63}
	binaryIDGlGetInteger64vAPPLE                             = binary.ID{0x33, 0x54, 0x3b, 0x22, 0xfa, 0xa3, 0xfd, 0x97, 0x69, 0x56, 0x4c, 0xff, 0x8a, 0x58, 0xd5, 0x8c, 0x33, 0xea, 0x43, 0xb6}
	binaryIDGlGetIntegeri_v                                  = binary.ID{0x13, 0xe7, 0x2a, 0x4c, 0x18, 0x89, 0xb5, 0x52, 0xab, 0x71, 0xf4, 0x3d, 0x2c, 0x20, 0xe3, 0x40, 0x31, 0x4f, 0x1e, 0x02}
	binaryIDGlGetIntegeri_vEXT                               = binary.ID{0x7a, 0xa7, 0x58, 0x8e, 0x3d, 0x50, 0x9e, 0xcf, 0x3c, 0xc5, 0x3b, 0xb4, 0xc9, 0x80, 0xd8, 0xe0, 0xbd, 0xde, 0x4f, 0xae}
	binaryIDGlGetIntegerv                                    = binary.ID{0x2f, 0x78, 0x38, 0xf6, 0xf1, 0x85, 0x3d, 0x81, 0xdb, 0x7e, 0xf3, 0xdb, 0x00, 0x9a, 0x52, 0xf1, 0x08, 0xd2, 0x1e, 0x46}
	binaryIDGlGetInternalformatSampleivNV                    = binary.ID{0x3e, 0x2b, 0xbf, 0x6e, 0x70, 0xfb, 0x62, 0x5e, 0xbb, 0x9a, 0x23, 0x44, 0x92, 0x34, 0x6c, 0xcb, 0x47, 0x20, 0x49, 0x87}
	binaryIDGlGetInternalformativ                            = binary.ID{0xd6, 0x9f, 0xa9, 0xb2, 0xb0, 0xbd, 0x70, 0xa0, 0xba, 0x87, 0xec, 0x5f, 0x03, 0x10, 0xb1, 0xd7, 0xee, 0xc5, 0x0a, 0x34}
	binaryIDGlGetMultisamplefv                               = binary.ID{0x4f, 0x4f, 0x2c, 0x18, 0xc1, 0xf9, 0x7d, 0xe1, 0x25, 0x96, 0xfc, 0x2e, 0x78, 0xc0, 0x28, 0x73, 0x45, 0xc8, 0x26, 0xfb}
	binaryIDGlGetNextPerfQueryIdINTEL                        = binary.ID{0x40, 0x59, 0xa0, 0xca, 0x12, 0x68, 0xce, 0x83, 0x82, 0x8d, 0xe1, 0x13, 0x84, 0xd3, 0x5c, 0x51, 0xb4, 0xd3, 0x98, 0xac}
	binaryIDGlGetObjectLabelEXT                              = binary.ID{0xc3, 0xa6, 0x4f, 0x4f, 0xcb, 0x22, 0x90, 0x13, 0x19, 0xcc, 0x24, 0x5a, 0xc8, 0x8d, 0xb5, 0x16, 0x98, 0xc6, 0x0b, 0x1d}
	binaryIDGlGetObjectLabelKHR                              = binary.ID{0xef, 0x64, 0x7b, 0xb2, 0x9f, 0x0b, 0x84, 0xb3, 0xea, 0x92, 0xe3, 0x2c, 0xcb, 0xfd, 0x6c, 0x74, 0x86, 0xe1, 0x7c, 0xc4}
	binaryIDGlGetObjectPtrLabelKHR                           = binary.ID{0xae, 0x26, 0x9b, 0xde, 0xf6, 0xae, 0x97, 0xb5, 0x02, 0x42, 0x41, 0x71, 0x90, 0x01, 0xf7, 0x62, 0xbe, 0x5d, 0x02, 0xbf}
	binaryIDGlGetPathCommandsNV                              = binary.ID{0xdd, 0x73, 0xac, 0xc4, 0x03, 0x8f, 0xf8, 0x20, 0xb9, 0x1a, 0xe9, 0xbd, 0xba, 0xd7, 0x43, 0x61, 0xf6, 0x91, 0x8b, 0x00}
	binaryIDGlGetPathCoordsNV                                = binary.ID{0x7e, 0xc7, 0xcc, 0x83, 0x00, 0xf6, 0x20, 0xa6, 0x36, 0xa3, 0x68, 0xf5, 0xdc, 0x55, 0x28, 0xa4, 0x5b, 0x1a, 0xad, 0x9b}
	binaryIDGlGetPathDashArrayNV                             = binary.ID{0x1b, 0xd5, 0x3d, 0x0f, 0x0a, 0x18, 0xc2, 0x1e, 0x4a, 0xd9, 0x95, 0xb3, 0xc9, 0x6f, 0x1a, 0x38, 0xa3, 0xfa, 0xd1, 0x3b}
	binaryIDGlGetPathLengthNV                                = binary.ID{0x2c, 0xd7, 0xc3, 0x3d, 0x3e, 0x51, 0xa9, 0x8b, 0xda, 0xdd, 0x75, 0x18, 0xfe, 0xe5, 0xc8, 0x9c, 0x0d, 0x51, 0xef, 0xa3}
	binaryIDGlGetPathMetricRangeNV                           = binary.ID{0xa2, 0xbe, 0x6c, 0x03, 0xcd, 0xa3, 0x19, 0xd8, 0xdc, 0x0e, 0x3a, 0x59, 0xe1, 0x22, 0x6a, 0x2c, 0x1c, 0xa6, 0x09, 0x93}
	binaryIDGlGetPathMetricsNV                               = binary.ID{0x2b, 0x15, 0xd5, 0xc8, 0x0d, 0x2b, 0x6d, 0xe7, 0x30, 0x12, 0xe8, 0x44, 0x60, 0xf2, 0x3c, 0xd0, 0xd0, 0xc8, 0xf6, 0xaa}
	binaryIDGlGetPathParameterfvNV                           = binary.ID{0xe3, 0x21, 0x35, 0xbb, 0x5d, 0x32, 0x81, 0x3a, 0x8c, 0xed, 0x00, 0x85, 0x76, 0x3b, 0x12, 0x0b, 0xe5, 0x36, 0x24, 0x8a}
	binaryIDGlGetPathParameterivNV                           = binary.ID{0x34, 0xb4, 0x9c, 0x73, 0x4c, 0x6f, 0x1e, 0xa8, 0x88, 0xb2, 0xe4, 0xc6, 0x94, 0xe0, 0xbd, 0x86, 0x4d, 0xdc, 0x4f, 0x1a}
	binaryIDGlGetPathSpacingNV                               = binary.ID{0xe0, 0x00, 0x52, 0xab, 0x7d, 0x2b, 0xc5, 0x21, 0x49, 0x04, 0x92, 0xea, 0xe1, 0x14, 0x10, 0x43, 0xf2, 0x33, 0x72, 0xce}
	binaryIDGlGetPerfCounterInfoINTEL                        = binary.ID{0xe4, 0xd1, 0x22, 0x77, 0xc0, 0x8b, 0x65, 0x9d, 0x3f, 0x0d, 0x4d, 0x6f, 0xaf, 0xf6, 0xc8, 0xf0, 0x83, 0x4d, 0x87, 0x1d}
	binaryIDGlGetPerfMonitorCounterDataAMD                   = binary.ID{0xe7, 0x3d, 0x3b, 0xa8, 0x26, 0xd0, 0x97, 0x1d, 0xe9, 0x23, 0xbc, 0x03, 0xb4, 0xef, 0xa2, 0x28, 0x5b, 0xa4, 0x2a, 0x7e}
	binaryIDGlGetPerfMonitorCounterInfoAMD                   = binary.ID{0xb2, 0x60, 0x54, 0x28, 0xad, 0x04, 0xc5, 0x46, 0xfb, 0xcf, 0xa9, 0xb4, 0xdf, 0x2b, 0x9c, 0xa5, 0xe0, 0xef, 0xf5, 0x59}
	binaryIDGlGetPerfMonitorCounterStringAMD                 = binary.ID{0x82, 0xb4, 0x7a, 0xdc, 0xa2, 0xc9, 0x1f, 0xd3, 0x9f, 0x48, 0x22, 0x67, 0xc8, 0xf9, 0x42, 0x07, 0x2a, 0xe3, 0xfa, 0x9a}
	binaryIDGlGetPerfMonitorCountersAMD                      = binary.ID{0x1e, 0xe5, 0xf9, 0x76, 0x3e, 0x82, 0xa8, 0xbb, 0x61, 0xfe, 0xd0, 0xdf, 0xbf, 0x15, 0xda, 0xf1, 0xa5, 0x38, 0x35, 0x8a}
	binaryIDGlGetPerfMonitorGroupStringAMD                   = binary.ID{0x1d, 0x1d, 0x50, 0x13, 0xd4, 0xb8, 0x03, 0x2d, 0xf6, 0x36, 0x0d, 0x32, 0x66, 0x5e, 0x8c, 0xa7, 0x17, 0xc4, 0xdd, 0x0a}
	binaryIDGlGetPerfMonitorGroupsAMD                        = binary.ID{0x37, 0x43, 0x6c, 0xaf, 0x38, 0x6e, 0x97, 0x0d, 0xf4, 0x0a, 0x13, 0x99, 0xfd, 0x8e, 0x3e, 0x9c, 0x83, 0xd7, 0x78, 0x04}
	binaryIDGlGetPerfQueryDataINTEL                          = binary.ID{0xd0, 0x68, 0xcf, 0x6f, 0x67, 0x1b, 0x32, 0x50, 0x11, 0x01, 0x11, 0x3a, 0xd3, 0xcb, 0x91, 0x5e, 0xbe, 0x5a, 0xc4, 0x33}
	binaryIDGlGetPerfQueryIdByNameINTEL                      = binary.ID{0xfe, 0xab, 0x96, 0x8e, 0x39, 0xe7, 0x6c, 0xa5, 0x90, 0x92, 0x96, 0x4f, 0x5d, 0xf5, 0xfb, 0xcf, 0x93, 0xa8, 0xe4, 0xc6}
	binaryIDGlGetPerfQueryInfoINTEL                          = binary.ID{0x2c, 0x21, 0x2e, 0xb3, 0x3d, 0x95, 0x9e, 0x73, 0x71, 0x4e, 0x5a, 0xda, 0x66, 0xe0, 0x8e, 0xad, 0x81, 0xe9, 0x90, 0xfd}
	binaryIDGlGetPointervKHR                                 = binary.ID{0xcc, 0x77, 0xd0, 0xa7, 0xbf, 0x3a, 0x4b, 0x5e, 0xb7, 0x4d, 0x1f, 0xfb, 0x6f, 0xbd, 0x53, 0xfd, 0x63, 0xcd, 0xc5, 0x59}
	binaryIDGlGetProgramBinary                               = binary.ID{0x3d, 0x3d, 0xc6, 0x41, 0xb6, 0x85, 0x89, 0xcd, 0xb5, 0xb6, 0xfe, 0xbf, 0x7a, 0x70, 0xa2, 0x5c, 0xa5, 0x9f, 0x9a, 0x6a}
	binaryIDGlGetProgramBinaryOES                            = binary.ID{0x4b, 0x9a, 0x69, 0xaf, 0x98, 0x33, 0x3d, 0xf2, 0xbf, 0xc9, 0x81, 0xec, 0x0d, 0x6a, 0xc4, 0xc4, 0x0a, 0x29, 0xd8, 0xd2}
	binaryIDGlGetProgramInfoLog                              = binary.ID{0x1f, 0x60, 0x34, 0xa3, 0xb8, 0x32, 0x99, 0x0f, 0xc6, 0xff, 0x44, 0x07, 0xb5, 0xfc, 0x55, 0x0d, 0x93, 0x9c, 0xe4, 0x7e}
	binaryIDGlGetProgramInterfaceiv                          = binary.ID{0x98, 0xfb, 0x3d, 0x01, 0xf3, 0x8f, 0xd4, 0x76, 0x07, 0xb5, 0xa4, 0xb9, 0xf6, 0x29, 0x90, 0xca, 0x6c, 0xf7, 0x0a, 0x30}
	binaryIDGlGetProgramPipelineInfoLog                      = binary.ID{0xa3, 0xcb, 0x38, 0x33, 0xa9, 0x04, 0x04, 0x6f, 0x4d, 0xb2, 0x9e, 0x45, 0x7c, 0x8d, 0x1a, 0x17, 0x1f, 0x1c, 0x33, 0xe4}
	binaryIDGlGetProgramPipelineInfoLogEXT                   = binary.ID{0x26, 0x52, 0x35, 0x30, 0x06, 0xad, 0xc9, 0x8a, 0xc1, 0xfb, 0xa2, 0x95, 0xa8, 0x53, 0x67, 0x95, 0x1b, 0x2c, 0xba, 0xd6}
	binaryIDGlGetProgramPipelineiv                           = binary.ID{0x05, 0xde, 0x13, 0xd5, 0xac, 0x79, 0xe4, 0x04, 0x27, 0x00, 0xf3, 0x39, 0xff, 0x2d, 0xf8, 0x1e, 0x8e, 0xba, 0xc3, 0x6a}
	binaryIDGlGetProgramPipelineivEXT                        = binary.ID{0x89, 0xb7, 0x2a, 0xe1, 0xdd, 0xef, 0xde, 0xee, 0xc6, 0xb8, 0x5c, 0x41, 0xf2, 0x15, 0xc6, 0xf6, 0x6b, 0x9e, 0x4f, 0x5e}
	binaryIDGlGetProgramResourceIndex                        = binary.ID{0xd9, 0xd7, 0xf7, 0xd9, 0x35, 0xda, 0x79, 0xce, 0x33, 0xa1, 0x8a, 0x06, 0xd7, 0x2b, 0x42, 0x54, 0x14, 0x97, 0x09, 0x19}
	binaryIDGlGetProgramResourceLocation                     = binary.ID{0x67, 0x4e, 0x00, 0xde, 0x99, 0xe5, 0x4f, 0xdc, 0x07, 0xce, 0x31, 0x79, 0x36, 0xe3, 0xf8, 0xbd, 0xb7, 0xc2, 0x2c, 0x79}
	binaryIDGlGetProgramResourceName                         = binary.ID{0xfc, 0x79, 0x9f, 0x5a, 0x73, 0xef, 0x0a, 0xbb, 0xc2, 0x87, 0xef, 0xe1, 0xad, 0xf3, 0xe2, 0xb5, 0x55, 0x5c, 0xe3, 0x9c}
	binaryIDGlGetProgramResourcefvNV                         = binary.ID{0x52, 0xad, 0x56, 0xef, 0x0e, 0x42, 0x90, 0xc5, 0x36, 0x87, 0x35, 0x47, 0x38, 0x16, 0x47, 0x8b, 0x9f, 0x6b, 0x0a, 0xb1}
	binaryIDGlGetProgramResourceiv                           = binary.ID{0xb3, 0x2d, 0x8c, 0xc9, 0xe9, 0x5d, 0xb3, 0x29, 0xd1, 0xda, 0xbe, 0x04, 0xf4, 0xba, 0xe3, 0x89, 0x75, 0x01, 0xae, 0xcc}
	binaryIDGlGetProgramiv                                   = binary.ID{0xfb, 0x60, 0x5f, 0x5a, 0x84, 0x6e, 0xa9, 0xc1, 0xa4, 0x1f, 0x4e, 0x73, 0xba, 0x15, 0xe1, 0x3c, 0x6f, 0xcc, 0xbe, 0x56}
	binaryIDS64ᵖ                                             = binary.ID{0xe9, 0x1c, 0x9a, 0xfd, 0xd1, 0xe3, 0x35, 0x1c, 0x32, 0xfd, 0x2c, 0x3f, 0xbc, 0x25, 0xaa, 0xbd, 0xcf, 0x3e, 0x7f, 0xbb}
	binaryIDGlGetQueryObjecti64v                             = binary.ID{0xfe, 0x93, 0xaa, 0x70, 0x07, 0x88, 0xa9, 0xfc, 0x4d, 0x31, 0xd0, 0x47, 0x68, 0xb8, 0x85, 0xf8, 0x0a, 0x78, 0x1d, 0x6c}
	binaryIDGlGetQueryObjecti64vEXT                          = binary.ID{0xfa, 0x28, 0x66, 0x98, 0x65, 0xdf, 0xf7, 0xd6, 0xd2, 0xa5, 0xf9, 0xa5, 0x61, 0xa3, 0x73, 0xac, 0xad, 0xdc, 0x0d, 0x36}
	binaryIDGlGetQueryObjectivEXT                            = binary.ID{0x88, 0x3d, 0x38, 0xf3, 0xe0, 0xad, 0x8d, 0xd2, 0x92, 0x64, 0x5e, 0x33, 0x99, 0xdc, 0x20, 0xd7, 0x65, 0xeb, 0xce, 0x07}
	binaryIDU64ᵖ                                             = binary.ID{0x00, 0x08, 0x7a, 0x1a, 0x40, 0x52, 0x66, 0xee, 0xbe, 0xb5, 0x0a, 0x76, 0xc8, 0xf9, 0x4a, 0x7d, 0x20, 0xd0, 0x0b, 0x8d}
	binaryIDGlGetQueryObjectui64v                            = binary.ID{0x66, 0x29, 0x57, 0xdf, 0xbf, 0xaf, 0x4b, 0x28, 0xeb, 0xef, 0x0e, 0x6d, 0x2a, 0xae, 0xc8, 0x44, 0x4c, 0x9e, 0x00, 0xfe}
	binaryIDGlGetQueryObjectui64vEXT                         = binary.ID{0x03, 0x2d, 0xf3, 0x3b, 0x0e, 0x75, 0xd0, 0xa3, 0x67, 0xb7, 0x94, 0x6b, 0x17, 0xa3, 0x8f, 0x38, 0x25, 0x56, 0x7f, 0xc6}
	binaryIDGlGetQueryObjectuiv                              = binary.ID{0x24, 0x16, 0x1f, 0x3f, 0x27, 0x2d, 0x72, 0x01, 0x32, 0x78, 0x81, 0x73, 0xd7, 0x3a, 0xff, 0x85, 0xd9, 0xee, 0x6c, 0x26}
	binaryIDGlGetQueryObjectuivEXT                           = binary.ID{0xa6, 0x97, 0xd6, 0x29, 0x81, 0x38, 0x7e, 0x2d, 0x1f, 0xbe, 0x51, 0x7a, 0x79, 0xd5, 0xfe, 0x31, 0xdf, 0x91, 0xd8, 0x29}
	binaryIDGlGetQueryiv                                     = binary.ID{0x32, 0x28, 0x67, 0x6d, 0x92, 0x88, 0xb3, 0x54, 0x95, 0x42, 0x80, 0x0c, 0x0f, 0x44, 0x58, 0x30, 0xe5, 0x7b, 0x08, 0x1c}
	binaryIDGlGetQueryivEXT                                  = binary.ID{0xcb, 0x06, 0x2f, 0x04, 0xb7, 0x8f, 0x9d, 0x52, 0xbb, 0x2a, 0xcb, 0x75, 0x49, 0xdc, 0xa9, 0x9e, 0xb2, 0x72, 0x0a, 0x13}
	binaryIDGlGetRenderbufferParameteriv                     = binary.ID{0x8d, 0x2f, 0x18, 0xcb, 0xf8, 0xdc, 0xb6, 0xfa, 0xd5, 0x73, 0x6a, 0x31, 0xb2, 0x1c, 0x53, 0x38, 0xd0, 0x1b, 0x6e, 0x8b}
	binaryIDGlGetSamplerParameterIivEXT                      = binary.ID{0x84, 0xa9, 0x6d, 0xa6, 0x65, 0xad, 0x5e, 0x2e, 0xcc, 0x56, 0x5a, 0x87, 0x45, 0x46, 0x20, 0xf0, 0x03, 0x2b, 0x6a, 0x1b}
	binaryIDGlGetSamplerParameterIivOES                      = binary.ID{0xd6, 0xbf, 0x78, 0xc0, 0xfe, 0x18, 0x4e, 0x64, 0xb7, 0x94, 0x21, 0x20, 0xcb, 0x4d, 0xe4, 0xff, 0xb2, 0xe2, 0x94, 0x14}
	binaryIDGlGetSamplerParameterIuivEXT                     = binary.ID{0x61, 0x03, 0x88, 0x21, 0x32, 0xbd, 0xc4, 0x14, 0x7f, 0x6e, 0x98, 0x31, 0x44, 0x7b, 0x6c, 0xb1, 0x2d, 0x35, 0xd3, 0x75}
	binaryIDGlGetSamplerParameterIuivOES                     = binary.ID{0xfb, 0x8a, 0xa5, 0xf0, 0xa0, 0x05, 0x68, 0x9e, 0x02, 0x3c, 0x93, 0xab, 0xc8, 0x1e, 0x3c, 0x16, 0x04, 0x6e, 0xe3, 0x62}
	binaryIDGlGetSamplerParameterfv                          = binary.ID{0x60, 0xda, 0x5d, 0xb0, 0x3f, 0x7c, 0xc6, 0x72, 0x7f, 0xa5, 0x49, 0x71, 0x4c, 0x64, 0x12, 0xa4, 0x6e, 0xa3, 0xe3, 0x01}
	binaryIDGlGetSamplerParameteriv                          = binary.ID{0x32, 0xf9, 0x63, 0xa2, 0x03, 0xb2, 0x83, 0x63, 0x2a, 0x45, 0x78, 0x33, 0xed, 0x7e, 0xeb, 0x46, 0xa7, 0x87, 0xbe, 0x10}
	binaryIDGlGetShaderInfoLog                               = binary.ID{0xca, 0xc9, 0x96, 0xde, 0x95, 0xbc, 0x5a, 0xa1, 0x29, 0x7e, 0x2c, 0xca, 0xa3, 0xcd, 0xf3, 0xe0, 0x38, 0x92, 0x94, 0xc2}
	binaryIDGlGetShaderPrecisionFormat                       = binary.ID{0xe1, 0xc6, 0x45, 0x02, 0x3d, 0xac, 0x8e, 0xab, 0x4a, 0x9e, 0xc7, 0x0a, 0xe8, 0xc6, 0xb6, 0x4e, 0xcc, 0x77, 0x4a, 0xe4}
	binaryIDGlGetShaderSource                                = binary.ID{0xe7, 0xbe, 0x15, 0x1c, 0xcb, 0xcd, 0x8a, 0xae, 0x90, 0x70, 0xb1, 0x7d, 0x52, 0x7e, 0xcb, 0x8b, 0xb2, 0x83, 0xe4, 0x5b}
	binaryIDGlGetShaderiv                                    = binary.ID{0xeb, 0x9c, 0x4c, 0x48, 0x41, 0x14, 0xf5, 0xc1, 0x26, 0x28, 0x5f, 0xf8, 0x5d, 0xf3, 0xfa, 0x6a, 0x20, 0x06, 0x5b, 0xe1}
	binaryIDGlGetString                                      = binary.ID{0x1c, 0x6c, 0x55, 0x17, 0x64, 0xe8, 0xef, 0x67, 0xe9, 0xdb, 0xaa, 0x5e, 0x79, 0x8c, 0xd6, 0x85, 0x2c, 0xaf, 0x2e, 0xb4}
	binaryIDGlGetStringi                                     = binary.ID{0x73, 0x0b, 0x5a, 0x6f, 0xdf, 0x64, 0x4c, 0xb6, 0x29, 0x7f, 0x35, 0x79, 0x48, 0x68, 0x20, 0x1c, 0xb2, 0x87, 0x49, 0xa8}
	binaryIDGlGetSynciv                                      = binary.ID{0x07, 0x44, 0x41, 0x1f, 0x3f, 0x3a, 0xf1, 0x41, 0x5c, 0x42, 0x5f, 0xae, 0x37, 0xcf, 0x92, 0x30, 0x14, 0xf5, 0xae, 0x45}
	binaryIDGlGetSyncivAPPLE                                 = binary.ID{0xe6, 0x3d, 0xb5, 0x40, 0x2b, 0xad, 0x0b, 0xbc, 0x95, 0xb1, 0x53, 0x21, 0xe0, 0xf5, 0x2d, 0xe2, 0x20, 0x41, 0x00, 0x91}
	binaryIDGlGetTexLevelParameterfv                         = binary.ID{0xf6, 0x85, 0x85, 0x7f, 0x34, 0x10, 0xa1, 0x51, 0xc0, 0x33, 0xf8, 0xd8, 0x17, 0x5a, 0xb6, 0xb9, 0x75, 0x31, 0xbe, 0xf9}
	binaryIDGlGetTexLevelParameteriv                         = binary.ID{0x98, 0x2f, 0x05, 0x4a, 0x23, 0xe8, 0x10, 0xf9, 0x8a, 0x98, 0x59, 0xa1, 0x4d, 0xf3, 0xf5, 0x03, 0x9d, 0xf2, 0x3e, 0xa7}
	binaryIDGlGetTexParameterIivEXT                          = binary.ID{0x0f, 0xed, 0xed, 0x95, 0xd9, 0xac, 0x7d, 0xbb, 0x2d, 0x84, 0x17, 0x66, 0xb3, 0x9f, 0x4e, 0xc9, 0xf3, 0x4e, 0xff, 0x08}
	binaryIDGlGetTexParameterIivOES                          = binary.ID{0xd6, 0x4d, 0x20, 0x8d, 0x3f, 0x0e, 0x35, 0xf0, 0x28, 0xb6, 0x03, 0x53, 0xb9, 0x83, 0xc1, 0xbf, 0xe4, 0x6a, 0x0f, 0x7e}
	binaryIDGlGetTexParameterIuivEXT                         = binary.ID{0x70, 0x60, 0xc9, 0x59, 0x16, 0xc0, 0xfb, 0x7f, 0xca, 0x73, 0xd2, 0xb0, 0x31, 0x43, 0x0f, 0xb2, 0x7c, 0xef, 0x33, 0xdb}
	binaryIDGlGetTexParameterIuivOES                         = binary.ID{0x6d, 0x0f, 0x39, 0x93, 0x80, 0x1a, 0x3d, 0x4e, 0xd7, 0x0d, 0xf0, 0x14, 0xcf, 0xb5, 0xab, 0x53, 0x48, 0x28, 0x6a, 0x75}
	binaryIDGlGetTexParameterfv                              = binary.ID{0x98, 0x02, 0xc0, 0x0b, 0x6b, 0x9b, 0xfc, 0xaf, 0x4f, 0xa2, 0x80, 0xa4, 0x62, 0x67, 0x69, 0xb5, 0xac, 0x7a, 0x96, 0xcb}
	binaryIDGlGetTexParameteriv                              = binary.ID{0x04, 0xd9, 0x74, 0x50, 0xa9, 0x58, 0xc8, 0x9e, 0x91, 0xf1, 0x88, 0x00, 0xb4, 0x49, 0xc9, 0xdf, 0xa3, 0x79, 0x25, 0x99}
	binaryIDGlGetTextureHandleNV                             = binary.ID{0xdb, 0xaa, 0xde, 0x4b, 0x97, 0x9e, 0xe6, 0x21, 0xeb, 0x73, 0x65, 0x40, 0xc1, 0x62, 0xc4, 0x68, 0x2f, 0xfa, 0xd8, 0x03}
	binaryIDGlGetTextureSamplerHandleNV                      = binary.ID{0xb4, 0x57, 0x1a, 0x07, 0x81, 0x60, 0x6d, 0x9e, 0x2e, 0x6d, 0x54, 0x6d, 0x2f, 0xaa, 0xad, 0xcd, 0x03, 0xe6, 0xc8, 0x84}
	binaryIDGlGetTransformFeedbackVarying                    = binary.ID{0x51, 0x5a, 0x47, 0x61, 0x69, 0x61, 0xcc, 0x0f, 0x14, 0x92, 0x09, 0x2a, 0xe1, 0xa1, 0xac, 0x62, 0x28, 0xc6, 0x50, 0x68}
	binaryIDGlGetTranslatedShaderSourceANGLE                 = binary.ID{0x40, 0xb4, 0x0d, 0x90, 0x35, 0xa5, 0x0a, 0x70, 0x71, 0x0a, 0x7d, 0x7a, 0xfc, 0x86, 0x91, 0x2a, 0xd0, 0x5d, 0x2a, 0x9f}
	binaryIDGlGetUniformBlockIndex                           = binary.ID{0x8e, 0xbc, 0x52, 0xd3, 0xc7, 0x7a, 0xcf, 0x55, 0x44, 0xef, 0x3e, 0x49, 0x14, 0x7b, 0x36, 0x54, 0x2e, 0xca, 0xbe, 0xa8}
	binaryIDGlGetUniformIndices                              = binary.ID{0xeb, 0x5f, 0x9f, 0x55, 0xe6, 0x2e, 0xe9, 0x9a, 0x0d, 0xa4, 0xe4, 0xcd, 0x46, 0x98, 0x1a, 0x82, 0x60, 0xfe, 0x55, 0xa1}
	binaryIDGlGetUniformLocation                             = binary.ID{0xd9, 0x4d, 0x1e, 0x3c, 0xe5, 0x99, 0xab, 0xf3, 0x3c, 0x4e, 0x27, 0xad, 0xd6, 0xd0, 0x7c, 0x6d, 0xb9, 0x4b, 0x2d, 0xc4}
	binaryIDGlGetUniformfv                                   = binary.ID{0x7e, 0x7b, 0x0d, 0xdb, 0xd6, 0x1a, 0x07, 0x5f, 0x78, 0x88, 0xff, 0xad, 0x74, 0x97, 0xf4, 0x30, 0x54, 0xd6, 0x6f, 0x89}
	binaryIDGlGetUniformiv                                   = binary.ID{0x3d, 0xf7, 0x66, 0xe4, 0xf9, 0xee, 0x98, 0x0e, 0xab, 0xf4, 0xe3, 0xec, 0xd2, 0x9e, 0xc4, 0x2d, 0xe4, 0xb6, 0xdd, 0x06}
	binaryIDGlGetUniformuiv                                  = binary.ID{0x98, 0x75, 0xe8, 0xa4, 0x60, 0x97, 0x7e, 0xe2, 0xc5, 0x1d, 0x3a, 0xc0, 0x15, 0x80, 0x15, 0x0e, 0xca, 0xc4, 0x37, 0x87}
	binaryIDGlGetVertexAttribIiv                             = binary.ID{0xc7, 0x30, 0x61, 0x4c, 0x20, 0x68, 0x23, 0x41, 0xfe, 0x4f, 0xc9, 0xb4, 0x6d, 0x9a, 0x15, 0x18, 0xd1, 0x46, 0x4a, 0x7b}
	binaryIDGlGetVertexAttribIuiv                            = binary.ID{0x06, 0x4b, 0xf1, 0xc2, 0x18, 0x8c, 0x50, 0x2c, 0x96, 0x2d, 0xc4, 0x26, 0x79, 0xf0, 0x9f, 0xc5, 0xbd, 0xbd, 0x07, 0x38}
	binaryIDGlGetVertexAttribPointerv                        = binary.ID{0x3e, 0x3b, 0x21, 0x57, 0x6a, 0xb2, 0x67, 0x32, 0xd9, 0x0c, 0xc3, 0xb9, 0xdb, 0x27, 0x0e, 0xd4, 0x00, 0xa7, 0xd5, 0xd8}
	binaryIDGlGetVertexAttribfv                              = binary.ID{0x43, 0x0f, 0xa7, 0x10, 0x8b, 0x76, 0xec, 0xe5, 0x9d, 0x4f, 0x37, 0xc7, 0x20, 0x96, 0xb0, 0x84, 0xb4, 0x85, 0x68, 0xb4}
	binaryIDGlGetVertexAttribiv                              = binary.ID{0x85, 0x52, 0xcf, 0x36, 0x59, 0xd7, 0xf7, 0x8f, 0xab, 0x8e, 0xdd, 0x07, 0x4d, 0x93, 0x91, 0x3e, 0xa1, 0x13, 0x39, 0x13}
	binaryIDGlGetnUniformfvEXT                               = binary.ID{0x1a, 0x85, 0x54, 0x34, 0x80, 0xdd, 0xa1, 0x19, 0x77, 0xcc, 0x6d, 0x09, 0x5b, 0x6b, 0x87, 0x8b, 0x8a, 0xe6, 0x50, 0x31}
	binaryIDGlGetnUniformfvKHR                               = binary.ID{0xe9, 0x22, 0x0f, 0x57, 0x9e, 0xe6, 0x80, 0x9c, 0x90, 0x4e, 0x7a, 0xcd, 0x76, 0x47, 0x0d, 0xe6, 0x5d, 0x49, 0x99, 0x51}
	binaryIDGlGetnUniformivEXT                               = binary.ID{0x8b, 0x9d, 0x78, 0x44, 0x88, 0xf0, 0x34, 0x2f, 0x49, 0x51, 0x8f, 0xb6, 0xf7, 0xc0, 0x2d, 0x6c, 0x5c, 0xad, 0xa8, 0xae}
	binaryIDGlGetnUniformivKHR                               = binary.ID{0xd0, 0x77, 0xbd, 0x82, 0x7e, 0x23, 0x53, 0x76, 0x88, 0xeb, 0x09, 0x7f, 0xd2, 0xe0, 0x47, 0x77, 0x89, 0x99, 0x3c, 0x28}
	binaryIDGlGetnUniformuivKHR                              = binary.ID{0x3c, 0xb9, 0x2b, 0xd2, 0x34, 0x35, 0x2e, 0x0b, 0xde, 0xc0, 0xcd, 0x60, 0x2d, 0x69, 0x6a, 0x69, 0xf4, 0x6c, 0x43, 0x41}
	binaryIDGlHint                                           = binary.ID{0x99, 0x8a, 0x57, 0x73, 0xe0, 0x3c, 0x8c, 0x3a, 0x80, 0xb7, 0x02, 0xcc, 0xf5, 0x66, 0x58, 0x95, 0x5a, 0xf5, 0x02, 0x81}
	binaryIDGlInsertEventMarkerEXT                           = binary.ID{0x25, 0xfc, 0x5a, 0x6d, 0x1f, 0x10, 0x9b, 0xdd, 0x1f, 0x22, 0x18, 0x33, 0xff, 0x80, 0x0d, 0x41, 0x05, 0x25, 0x31, 0x6a}
	binaryIDGlInterpolatePathsNV                             = binary.ID{0xf1, 0x3f, 0x62, 0x9d, 0xc0, 0x60, 0x18, 0x46, 0x59, 0x6c, 0xa1, 0x45, 0x08, 0x2c, 0x36, 0xd2, 0xa0, 0xff, 0xae, 0xc6}
	binaryIDGlInvalidateFramebuffer                          = binary.ID{0xdb, 0x61, 0xf4, 0xea, 0xf6, 0xd0, 0x32, 0x53, 0xd9, 0xe3, 0xb8, 0x49, 0xe3, 0x7b, 0x4e, 0x3d, 0x21, 0x57, 0xae, 0xfc}
	binaryIDGlInvalidateSubFramebuffer                       = binary.ID{0x4e, 0xf4, 0x42, 0xeb, 0x9a, 0x66, 0xc5, 0xe3, 0x09, 0x6c, 0x2f, 0x32, 0x7a, 0x81, 0x05, 0x8c, 0xe3, 0x59, 0x49, 0x59}
	binaryIDGlIsBuffer                                       = binary.ID{0xd1, 0x42, 0xad, 0xb7, 0x81, 0x67, 0x04, 0x3a, 0x6e, 0x6a, 0x0a, 0x72, 0x75, 0xcb, 0x7c, 0x15, 0xa1, 0x9a, 0xf8, 0x66}
	binaryIDGlIsEnabled                                      = binary.ID{0xdf, 0xea, 0x56, 0xfa, 0xb1, 0x23, 0x94, 0xf6, 0x32, 0xef, 0x9e, 0x76, 0x22, 0x90, 0x9e, 0x64, 0x72, 0x78, 0x9a, 0x77}
	binaryIDGlIsEnablediEXT                                  = binary.ID{0xae, 0x61, 0xac, 0xf0, 0xa8, 0x0a, 0xda, 0xd4, 0x62, 0x6f, 0x79, 0x2a, 0x94, 0xcc, 0x5b, 0x49, 0xde, 0xea, 0x1c, 0xfc}
	binaryIDGlIsEnablediNV                                   = binary.ID{0x23, 0x7a, 0xc2, 0xbc, 0x0c, 0x99, 0xbd, 0xa3, 0x4a, 0x46, 0xb7, 0x73, 0xe3, 0xaf, 0xfe, 0xe9, 0x57, 0x71, 0xf8, 0xd5}
	binaryIDGlIsEnablediOES                                  = binary.ID{0xdc, 0x6b, 0x8a, 0x3f, 0x3a, 0xcb, 0xdb, 0x01, 0xc1, 0xc6, 0x0e, 0x8e, 0xab, 0x90, 0xfb, 0x0d, 0x76, 0x5e, 0xb2, 0xad}
	binaryIDGlIsFenceNV                                      = binary.ID{0x00, 0xbe, 0x20, 0x72, 0x2b, 0x08, 0x81, 0xee, 0x1e, 0x4c, 0xae, 0x5b, 0x5e, 0x61, 0x2c, 0x78, 0x6c, 0xcc, 0x58, 0xfa}
	binaryIDGlIsFramebuffer                                  = binary.ID{0x18, 0x61, 0x06, 0x59, 0x8f, 0x47, 0x18, 0x3d, 0xc9, 0x38, 0x46, 0x78, 0x2e, 0x71, 0x54, 0x29, 0x9b, 0x9f, 0xc6, 0x33}
	binaryIDGlIsImageHandleResidentNV                        = binary.ID{0x53, 0xe4, 0x84, 0xe2, 0x4e, 0x7e, 0xbf, 0x3f, 0xae, 0xac, 0x62, 0x67, 0x00, 0xc5, 0xbc, 0x10, 0x9e, 0x04, 0x11, 0xf7}
	binaryIDGlIsPathNV                                       = binary.ID{0x11, 0x8e, 0xe3, 0x7e, 0xd5, 0x0a, 0x80, 0x9f, 0xb2, 0xb3, 0x72, 0xc6, 0xc6, 0x3a, 0x5c, 0x7d, 0xc5, 0x00, 0x48, 0xde}
	binaryIDGlIsPointInFillPathNV                            = binary.ID{0x21, 0x3c, 0x21, 0xd4, 0xa6, 0xf1, 0xa7, 0xcf, 0xef, 0x46, 0x10, 0xe4, 0x3f, 0xa8, 0xc5, 0xf3, 0x5c, 0xe7, 0x9a, 0x46}
	binaryIDGlIsPointInStrokePathNV                          = binary.ID{0xe2, 0x25, 0x1e, 0xa9, 0x3b, 0x3c, 0x88, 0x47, 0xde, 0x73, 0xb3, 0xd8, 0x3c, 0x22, 0x91, 0x58, 0xcd, 0xba, 0xca, 0x9a}
	binaryIDGlIsProgram                                      = binary.ID{0x3d, 0x4b, 0x04, 0xa2, 0x10, 0x91, 0x77, 0xc4, 0x5b, 0xf7, 0x7b, 0x52, 0x88, 0xb8, 0x23, 0xb4, 0x8b, 0x1d, 0x49, 0x8a}
	binaryIDGlIsProgramPipeline                              = binary.ID{0x65, 0x87, 0x32, 0x9b, 0x5e, 0x93, 0x56, 0x50, 0xb5, 0x80, 0x11, 0xcf, 0xa9, 0xea, 0x41, 0x79, 0x91, 0x56, 0xea, 0xf5}
	binaryIDGlIsProgramPipelineEXT                           = binary.ID{0x20, 0x45, 0x4b, 0x4e, 0xdc, 0x7d, 0x13, 0xe1, 0xe0, 0xd8, 0x3e, 0x59, 0x26, 0x75, 0x7b, 0x9e, 0x20, 0x11, 0x92, 0x53}
	binaryIDGlIsQuery                                        = binary.ID{0xeb, 0xf4, 0x49, 0xc3, 0xc4, 0x7f, 0xcf, 0x88, 0xd6, 0xba, 0xcd, 0xd3, 0x71, 0xf4, 0x54, 0x11, 0xc0, 0x5f, 0x39, 0x6c}
	binaryIDGlIsQueryEXT                                     = binary.ID{0xe4, 0x92, 0x78, 0x2c, 0x94, 0x95, 0xb9, 0x72, 0xd8, 0x48, 0xa9, 0x22, 0x2e, 0xbe, 0xc9, 0x93, 0x52, 0x14, 0x68, 0x80}
	binaryIDGlIsRenderbuffer                                 = binary.ID{0x34, 0x29, 0x3a, 0x38, 0xe1, 0xd5, 0x24, 0x3f, 0xfc, 0xc1, 0x68, 0xb5, 0x19, 0x3b, 0x96, 0xcc, 0x06, 0xd2, 0xa0, 0x78}
	binaryIDGlIsSampler                                      = binary.ID{0x5a, 0x71, 0x95, 0xd5, 0x3d, 0x8a, 0x37, 0x3f, 0xef, 0x3c, 0x68, 0x22, 0x10, 0x11, 0x15, 0x39, 0x66, 0xde, 0x16, 0xc9}
	binaryIDGlIsShader                                       = binary.ID{0xa7, 0x49, 0xe5, 0x16, 0x9b, 0xf3, 0x3e, 0x13, 0xba, 0x90, 0x7a, 0x71, 0x99, 0x9b, 0xd3, 0x77, 0x68, 0xa4, 0xb1, 0xe6}
	binaryIDGlIsSync                                         = binary.ID{0xa4, 0x39, 0x5f, 0xae, 0xa8, 0xe2, 0x66, 0x9d, 0x53, 0xcc, 0x8d, 0x93, 0xa3, 0x60, 0x08, 0x19, 0x9c, 0x2e, 0xe8, 0x78}
	binaryIDGlIsSyncAPPLE                                    = binary.ID{0x56, 0x15, 0x61, 0xaa, 0xec, 0x7f, 0x97, 0xe1, 0xad, 0x1e, 0x61, 0xea, 0x8e, 0x2b, 0xb1, 0xe5, 0x47, 0x39, 0x0c, 0x93}
	binaryIDGlIsTexture                                      = binary.ID{0x5b, 0xe3, 0xe7, 0xfa, 0xf3, 0x8f, 0xef, 0x75, 0xff, 0xf5, 0xab, 0xe8, 0xa5, 0xf6, 0xca, 0x21, 0xfa, 0xf9, 0x44, 0x38}
	binaryIDGlIsTextureHandleResidentNV                      = binary.ID{0x4e, 0x07, 0x08, 0x21, 0x50, 0x6f, 0x16, 0xf4, 0x6c, 0x14, 0x7a, 0x47, 0xe7, 0x3b, 0xb3, 0x3c, 0x6b, 0xc4, 0xa3, 0xb2}
	binaryIDGlIsTransformFeedback                            = binary.ID{0x32, 0x19, 0xd3, 0xf0, 0xb0, 0x03, 0x77, 0x57, 0x2f, 0x77, 0x27, 0x12, 0x4a, 0x61, 0x32, 0xd3, 0xbb, 0xd7, 0x70, 0xc9}
	binaryIDGlIsVertexArray                                  = binary.ID{0x05, 0x80, 0x6b, 0x17, 0xc1, 0x95, 0x55, 0x32, 0x24, 0xa9, 0xcb, 0x99, 0x7d, 0x49, 0xfc, 0x8b, 0xd2, 0xfa, 0xd3, 0x2d}
	binaryIDGlIsVertexArrayOES                               = binary.ID{0xb7, 0x33, 0xcc, 0xf5, 0x7b, 0x60, 0x3f, 0x6e, 0xe4, 0xf6, 0xad, 0xaf, 0xd2, 0xd1, 0xad, 0xba, 0x86, 0x4c, 0x12, 0xa8}
	binaryIDGlLabelObjectEXT                                 = binary.ID{0xb9, 0x3e, 0x8d, 0xf0, 0x23, 0xb2, 0x1b, 0x2c, 0x02, 0x10, 0x73, 0xec, 0x0b, 0x1d, 0x23, 0x7d, 0x87, 0x37, 0xe8, 0xd7}
	binaryIDGlLineWidth                                      = binary.ID{0x93, 0x5b, 0xc3, 0x68, 0x79, 0x91, 0x57, 0xc2, 0x9c, 0x41, 0x25, 0x25, 0x06, 0x5a, 0x2c, 0xeb, 0xf5, 0x7a, 0x43, 0x85}
	binaryIDGlLinkProgram                                    = binary.ID{0x17, 0xf0, 0x30, 0xba, 0x15, 0x5a, 0xf7, 0x20, 0x04, 0x04, 0xea, 0xd7, 0xc3, 0xba, 0x6a, 0x4c, 0x9e, 0x0d, 0x96, 0x41}
	binaryIDGlMakeImageHandleNonResidentNV                   = binary.ID{0x32, 0xe9, 0x40, 0x5c, 0x75, 0x41, 0xa6, 0x93, 0x3e, 0xf7, 0x55, 0xfc, 0x90, 0xa6, 0x00, 0x7b, 0x86, 0x49, 0x21, 0x21}
	binaryIDGlMakeImageHandleResidentNV                      = binary.ID{0xe9, 0x8c, 0xab, 0xff, 0x03, 0x6e, 0x38, 0x0a, 0xb3, 0xa9, 0x39, 0x70, 0xd7, 0xcb, 0x4b, 0xac, 0xe9, 0x7c, 0x38, 0x61}
	binaryIDGlMakeTextureHandleNonResidentNV                 = binary.ID{0x47, 0x8c, 0xa0, 0x46, 0x67, 0x1c, 0x30, 0xc0, 0xb0, 0x0b, 0x00, 0x43, 0x6a, 0x51, 0x14, 0x80, 0xa1, 0xbb, 0x5c, 0x7c}
	binaryIDGlMakeTextureHandleResidentNV                    = binary.ID{0x61, 0x5d, 0xc0, 0x7e, 0x78, 0xa4, 0x2d, 0x58, 0x91, 0x83, 0xd5, 0xe6, 0x4e, 0x78, 0x7f, 0xb4, 0xb2, 0x89, 0xac, 0xa1}
	binaryIDGlMapBufferOES                                   = binary.ID{0x4f, 0xc3, 0x63, 0x5d, 0xbf, 0xe0, 0xe1, 0x6c, 0x7f, 0xfa, 0x33, 0xcc, 0x78, 0x25, 0xf3, 0xb5, 0x5f, 0x6a, 0xec, 0x58}
	binaryIDGlMapBufferRange                                 = binary.ID{0xe7, 0x69, 0x95, 0x7e, 0x88, 0xfb, 0xad, 0x7b, 0xce, 0x34, 0xef, 0x50, 0x14, 0xcc, 0x6f, 0x4e, 0xc3, 0xda, 0x40, 0x91}
	binaryIDGlMapBufferRangeEXT                              = binary.ID{0xa5, 0xbc, 0xf6, 0x60, 0x5c, 0xa2, 0x80, 0x3a, 0x11, 0x70, 0xaa, 0x6a, 0x90, 0x0c, 0x90, 0xdd, 0xc2, 0xe5, 0x9d, 0x8e}
	binaryIDGlMatrixLoad3x2fNV                               = binary.ID{0x6d, 0x32, 0x09, 0x71, 0x47, 0x6b, 0xf4, 0x74, 0x99, 0xcf, 0xc8, 0x7e, 0xd0, 0xf5, 0x1b, 0x8b, 0x69, 0x80, 0xf8, 0x4b}
	binaryIDGlMatrixLoad3x3fNV                               = binary.ID{0x24, 0xb2, 0x46, 0x2d, 0x7e, 0x77, 0xfa, 0xc2, 0xa9, 0x16, 0x21, 0x96, 0xbf, 0x75, 0xba, 0x40, 0xa6, 0x08, 0x8f, 0xef}
	binaryIDGlMatrixLoadTranspose3x3fNV                      = binary.ID{0xc3, 0x43, 0x6e, 0xce, 0xf1, 0x7e, 0xce, 0x89, 0x86, 0x8e, 0x6b, 0xaf, 0xd3, 0x77, 0xf1, 0x0e, 0x9c, 0x93, 0x60, 0x87}
	binaryIDGlMatrixMult3x2fNV                               = binary.ID{0x1e, 0x85, 0xde, 0x2c, 0xd6, 0xb1, 0x45, 0x24, 0x48, 0xe4, 0x91, 0x6e, 0x93, 0x3a, 0x4f, 0x89, 0x6b, 0xfb, 0x5c, 0x87}
	binaryIDGlMatrixMult3x3fNV                               = binary.ID{0x03, 0x67, 0xa6, 0xd5, 0x9a, 0x04, 0x76, 0x52, 0x49, 0x49, 0x03, 0x45, 0x2c, 0x9e, 0x1b, 0xb5, 0x67, 0x12, 0x11, 0x62}
	binaryIDGlMatrixMultTranspose3x3fNV                      = binary.ID{0x03, 0xbe, 0x50, 0x41, 0x3e, 0xd8, 0xd6, 0xe7, 0xaf, 0x10, 0x5a, 0x48, 0xa5, 0x58, 0x5e, 0x0a, 0xff, 0x90, 0xfc, 0xa9}
	binaryIDGlMemoryBarrier                                  = binary.ID{0x87, 0x0c, 0x05, 0xe4, 0x93, 0x20, 0x1d, 0x0d, 0x00, 0xd3, 0xc8, 0x0c, 0xf1, 0x29, 0xd8, 0x3d, 0xc2, 0xfa, 0x0b, 0xd4}
	binaryIDGlMemoryBarrierByRegion                          = binary.ID{0xd3, 0x3f, 0x60, 0x4b, 0x14, 0xf1, 0x28, 0x82, 0xaf, 0x9d, 0xad, 0xe4, 0x68, 0x46, 0xc1, 0xdb, 0xad, 0xfd, 0x94, 0x93}
	binaryIDGlMinSampleShadingOES                            = binary.ID{0x5e, 0xfa, 0xff, 0x41, 0xd7, 0x9f, 0x63, 0xe7, 0x98, 0xeb, 0x4a, 0xe4, 0x0f, 0x74, 0x04, 0x2a, 0x9a, 0x98, 0xb3, 0x81}
	binaryIDGlMultiDrawArraysEXT                             = binary.ID{0x86, 0xf4, 0x5b, 0xcf, 0xbe, 0xcf, 0x38, 0x00, 0xd9, 0x95, 0xea, 0x35, 0x02, 0xd8, 0x7e, 0xe3, 0x86, 0x58, 0x29, 0xab}
	binaryIDGlMultiDrawArraysIndirectEXT                     = binary.ID{0xd9, 0xdc, 0xcb, 0x55, 0xca, 0xd7, 0xd5, 0xbe, 0x85, 0x09, 0xb2, 0x0f, 0xac, 0x2c, 0x17, 0x60, 0x4f, 0xe3, 0x75, 0x97}
	binaryIDVoidᶜᵖᶜᵖ                                         = binary.ID{0x33, 0xb8, 0xf9, 0xe3, 0xae, 0x15, 0xf1, 0xa2, 0x1b, 0xc5, 0x52, 0x23, 0x1f, 0xc0, 0x07, 0x65, 0xe6, 0xae, 0x0d, 0x3e}
	binaryIDGlMultiDrawElementsBaseVertexEXT                 = binary.ID{0x52, 0x43, 0xfa, 0xa7, 0xbc, 0xb3, 0x0c, 0x75, 0x8d, 0xef, 0x76, 0xb3, 0x73, 0xc4, 0x85, 0x61, 0x7b, 0xed, 0x06, 0x68}
	binaryIDGlMultiDrawElementsBaseVertexOES                 = binary.ID{0x24, 0x06, 0x57, 0x70, 0xf1, 0x77, 0x10, 0x66, 0xc0, 0xe8, 0x29, 0xf9, 0xb3, 0xc1, 0x1c, 0xd5, 0xa2, 0x8e, 0x52, 0x3e}
	binaryIDGlMultiDrawElementsEXT                           = binary.ID{0x86, 0x3f, 0x30, 0xa5, 0x7e, 0x36, 0xaa, 0xfc, 0x82, 0x32, 0x0b, 0xb4, 0x68, 0x6c, 0x6e, 0xf0, 0x61, 0xc9, 0x02, 0x15}
	binaryIDGlMultiDrawElementsIndirectEXT                   = binary.ID{0x0a, 0x14, 0x5b, 0xe3, 0xfa, 0xbd, 0x14, 0x49, 0xac, 0x50, 0x77, 0xd8, 0x78, 0x9d, 0x19, 0x39, 0xf3, 0x9f, 0x89, 0xac}
	binaryIDGlNamedFramebufferSampleLocationsfvNV            = binary.ID{0x43, 0xb8, 0x83, 0xea, 0x00, 0xbf, 0x02, 0xb2, 0x61, 0xfb, 0x92, 0xb8, 0x5b, 0x91, 0xc6, 0xba, 0x36, 0xd0, 0x5d, 0xaa}
	binaryIDGlObjectLabelKHR                                 = binary.ID{0x51, 0xe6, 0x4b, 0x36, 0x04, 0xb3, 0x72, 0xe7, 0x40, 0xf3, 0x74, 0xce, 0x19, 0x9c, 0xac, 0xe5, 0xfb, 0x2d, 0x4d, 0xbb}
	binaryIDGlObjectPtrLabelKHR                              = binary.ID{0x99, 0x7d, 0xe8, 0x77, 0xdf, 0x67, 0x27, 0x03, 0x5f, 0x10, 0x58, 0x5f, 0xb9, 0x2a, 0xf9, 0x21, 0x23, 0x98, 0xc1, 0xdd}
	binaryIDGlPatchParameteriEXT                             = binary.ID{0x95, 0xc2, 0x8c, 0x25, 0x8e, 0xd5, 0x07, 0x40, 0xb9, 0xb2, 0xff, 0xa7, 0x49, 0x76, 0x4f, 0x92, 0xa5, 0x34, 0x17, 0xf2}
	binaryIDGlPatchParameteriOES                             = binary.ID{0xc4, 0xb0, 0x5b, 0x85, 0x16, 0x65, 0x1e, 0x1a, 0xbe, 0x7e, 0x4e, 0x59, 0x75, 0xeb, 0x6e, 0xfe, 0x90, 0x10, 0xbf, 0xf0}
	binaryIDGlPathCommandsNV                                 = binary.ID{0x99, 0x1c, 0x51, 0xa0, 0xbb, 0xd0, 0x9a, 0x5f, 0x39, 0xa1, 0x8c, 0xe6, 0xda, 0xd7, 0x08, 0x7f, 0xf7, 0xb7, 0xf9, 0xb4}
	binaryIDGlPathCoordsNV                                   = binary.ID{0x9a, 0x04, 0x24, 0x51, 0xfa, 0xe6, 0x4c, 0x41, 0x11, 0x7d, 0x05, 0x49, 0x12, 0xc4, 0x65, 0x03, 0x3f, 0xd5, 0x57, 0x7c}
	binaryIDGlPathCoverDepthFuncNV                           = binary.ID{0xb7, 0xa1, 0x01, 0xe0, 0xd1, 0x33, 0xb7, 0x83, 0xfc, 0xc7, 0xf5, 0xce, 0x96, 0x8f, 0xe6, 0xe1, 0xd2, 0x24, 0x10, 0xf8}
	binaryIDGlPathDashArrayNV                                = binary.ID{0x02, 0x98, 0xcb, 0x6e, 0x2e, 0xd2, 0x22, 0x06, 0xdf, 0x5f, 0x51, 0xa4, 0x5d, 0xf0, 0x63, 0x2b, 0x38, 0x8e, 0xdd, 0x8d}
	binaryIDGlPathGlyphIndexArrayNV                          = binary.ID{0x2b, 0x06, 0x22, 0x45, 0x05, 0xf5, 0x0b, 0xfb, 0x9d, 0xa0, 0x2b, 0x07, 0x48, 0xb8, 0x55, 0x7c, 0x82, 0xde, 0xd0, 0xc3}
	binaryIDGlPathGlyphIndexRangeNV                          = binary.ID{0x81, 0x9a, 0x02, 0x6a, 0xf1, 0xd3, 0x8a, 0xac, 0x69, 0xc3, 0xec, 0x3b, 0x42, 0x69, 0x41, 0x4a, 0x35, 0xf0, 0x8f, 0xd1}
	binaryIDGlPathGlyphRangeNV                               = binary.ID{0xca, 0x0d, 0xab, 0x40, 0x5a, 0x1f, 0xf6, 0xf0, 0xd0, 0x32, 0x15, 0xcc, 0x8e, 0x92, 0x2e, 0x4e, 0x30, 0xd3, 0x38, 0x81}
	binaryIDGlPathGlyphsNV                                   = binary.ID{0x4b, 0xf0, 0xf6, 0x12, 0xe1, 0x5f, 0x06, 0x34, 0x68, 0x2d, 0xa4, 0x5f, 0xb8, 0x06, 0xe7, 0xb4, 0xca, 0x7f, 0x3a, 0x49}
	binaryIDGlPathMemoryGlyphIndexArrayNV                    = binary.ID{0x4d, 0xa5, 0xee, 0x83, 0x6d, 0x21, 0x7e, 0x32, 0x7a, 0x99, 0x28, 0x99, 0x5e, 0xa7, 0x8d, 0x69, 0x45, 0x06, 0x4f, 0xad}
	binaryIDGlPathParameterfNV                               = binary.ID{0xf1, 0xe8, 0xb7, 0xf0, 0x04, 0x8c, 0x8c, 0x40, 0x5e, 0x00, 0xdc, 0xc3, 0xdc, 0x9d, 0x97, 0x2e, 0x6a, 0x14, 0x5a, 0xc0}
	binaryIDGlPathParameterfvNV                              = binary.ID{0x0e, 0x7b, 0xd6, 0x31, 0x4b, 0x2e, 0x46, 0x94, 0x09, 0x7a, 0x91, 0xdc, 0x29, 0xe5, 0xb2, 0xa6, 0x26, 0x44, 0x75, 0x6e}
	binaryIDGlPathParameteriNV                               = binary.ID{0xfa, 0x95, 0x9e, 0x7a, 0xdd, 0x90, 0x3f, 0x85, 0xcb, 0xea, 0x24, 0xe0, 0x23, 0xac, 0x18, 0xb0, 0x20, 0x2b, 0x13, 0x86}
	binaryIDGlPathParameterivNV                              = binary.ID{0x8a, 0xa0, 0xb4, 0x4d, 0x3b, 0x83, 0xd1, 0xa1, 0xb7, 0xf4, 0x66, 0x74, 0xe1, 0xe6, 0xe6, 0xe1, 0x6b, 0x1a, 0x48, 0x95}
	binaryIDGlPathStencilDepthOffsetNV                       = binary.ID{0xa2, 0x96, 0x57, 0x3c, 0xb3, 0xd4, 0x8c, 0xf6, 0x7a, 0xdb, 0xd4, 0xd3, 0x4c, 0x75, 0x1a, 0x1e, 0xc9, 0x78, 0x1d, 0x22}
	binaryIDGlPathStencilFuncNV                              = binary.ID{0x92, 0x44, 0xb2, 0x2e, 0xa1, 0x4a, 0x5c, 0x49, 0x80, 0xa1, 0x55, 0x83, 0x9a, 0x63, 0xc4, 0x4c, 0xce, 0x9c, 0x0b, 0xd2}
	binaryIDGlPathStringNV                                   = binary.ID{0x01, 0x60, 0xb2, 0x12, 0x9e, 0x64, 0x29, 0xf2, 0x04, 0x58, 0xbd, 0xde, 0x01, 0x47, 0x60, 0x6f, 0x67, 0x0d, 0x71, 0xd8}
	binaryIDGlPathSubCommandsNV                              = binary.ID{0x26, 0x90, 0x92, 0x07, 0x8c, 0x24, 0xb5, 0x38, 0x86, 0x45, 0xf2, 0x69, 0xe2, 0x87, 0x98, 0x96, 0xc1, 0xa4, 0xf9, 0x83}
	binaryIDGlPathSubCoordsNV                                = binary.ID{0xf9, 0x70, 0xe9, 0xd5, 0xa7, 0x0b, 0xd2, 0xeb, 0x40, 0x39, 0xe1, 0xe2, 0xb2, 0x98, 0x7f, 0x12, 0x00, 0x2a, 0x93, 0xa8}
	binaryIDGlPauseTransformFeedback                         = binary.ID{0x23, 0xab, 0x2a, 0x64, 0xe4, 0x2a, 0x4c, 0x71, 0x8d, 0xc2, 0xce, 0xc4, 0xa5, 0xcb, 0xcd, 0x53, 0xa6, 0xdc, 0xde, 0x4f}
	binaryIDGlPixelStorei                                    = binary.ID{0x42, 0x6b, 0x22, 0x28, 0x99, 0x28, 0x2c, 0xce, 0x9a, 0x53, 0xf4, 0x53, 0x3e, 0xd7, 0x44, 0x48, 0x8e, 0xd4, 0x11, 0x36}
	binaryIDGlPointAlongPathNV                               = binary.ID{0x6c, 0x0f, 0x3c, 0x94, 0x90, 0xc6, 0xd1, 0x2f, 0x0a, 0x35, 0xb7, 0x07, 0x82, 0xd4, 0x41, 0x9f, 0xd2, 0xf3, 0xe6, 0x30}
	binaryIDGlPolygonModeNV                                  = binary.ID{0x4c, 0x0b, 0xb5, 0x62, 0xe6, 0x05, 0x08, 0x70, 0x6a, 0x3e, 0xc9, 0x55, 0x0c, 0x67, 0x84, 0xd1, 0x0b, 0x6d, 0x7c, 0x26}
	binaryIDGlPolygonOffset                                  = binary.ID{0x77, 0xd9, 0x9f, 0xb4, 0x8f, 0x74, 0xe9, 0x76, 0x86, 0xe3, 0xec, 0x65, 0xb2, 0xe0, 0xcf, 0xd9, 0xf7, 0xb6, 0x8d, 0xe5}
	binaryIDGlPopDebugGroupKHR                               = binary.ID{0xe0, 0x5b, 0xe4, 0xda, 0x20, 0xae, 0x4f, 0xfb, 0x0c, 0xfd, 0xc0, 0xa8, 0x5c, 0x0d, 0x66, 0x0e, 0x8f, 0xc2, 0x24, 0xf9}
	binaryIDGlPopGroupMarkerEXT                              = binary.ID{0x63, 0xb8, 0xb9, 0x5e, 0x5d, 0xf9, 0x13, 0xbb, 0xc7, 0xce, 0x02, 0x0f, 0xc7, 0x14, 0x03, 0x22, 0xe5, 0x70, 0x9f, 0x87}
	binaryIDGlPrimitiveBoundingBoxEXT                        = binary.ID{0x95, 0x61, 0x16, 0x23, 0x7a, 0xcb, 0xc5, 0x39, 0x91, 0x21, 0xf6, 0x4a, 0x3e, 0xbf, 0xfd, 0x27, 0x9d, 0x47, 0xca, 0xb1}
	binaryIDGlPrimitiveBoundingBoxOES                        = binary.ID{0x6f, 0x1d, 0x80, 0xe9, 0xa1, 0xf0, 0x9a, 0xa2, 0xee, 0xe7, 0x29, 0x7d, 0x17, 0x14, 0x2a, 0xb7, 0xd7, 0xb4, 0x14, 0x9d}
	binaryIDGlProgramBinary                                  = binary.ID{0x93, 0xa3, 0x29, 0x4d, 0x2f, 0x1b, 0xac, 0x3f, 0x99, 0x89, 0xb7, 0x1f, 0xe0, 0x93, 0xb4, 0x2e, 0x51, 0x14, 0x2c, 0x79}
	binaryIDGlProgramBinaryOES                               = binary.ID{0xd6, 0xa3, 0x55, 0x27, 0xc0, 0x9e, 0x41, 0xc5, 0x21, 0x2b, 0x8c, 0x70, 0x43, 0xd9, 0x6a, 0x34, 0x7f, 0xc2, 0x1c, 0xef}
	binaryIDGlProgramParameteri                              = binary.ID{0x72, 0x10, 0xc6, 0x95, 0x5a, 0x4d, 0xba, 0x2b, 0x89, 0x10, 0x22, 0x56, 0x86, 0xdc, 0xf8, 0xa3, 0x68, 0x65, 0x22, 0x4a}
	binaryIDGlProgramParameteriEXT                           = binary.ID{0x0f, 0xed, 0x0d, 0x7f, 0x77, 0x69, 0xe0, 0x24, 0xf3, 0x78, 0x63, 0xad, 0x97, 0x44, 0xf2, 0x20, 0x18, 0xa6, 0x1c, 0x26}
	binaryIDGlProgramPathFragmentInputGenNV                  = binary.ID{0x7b, 0x5b, 0x3f, 0x42, 0x7a, 0x5f, 0x01, 0xe1, 0xcf, 0x87, 0xd2, 0xa2, 0x33, 0xc0, 0x5b, 0x9b, 0xc8, 0x16, 0x32, 0x9e}
	binaryIDGlProgramUniform1f                               = binary.ID{0x1e, 0xe5, 0x1a, 0x0e, 0x20, 0xc6, 0xbb, 0xa5, 0x9a, 0x64, 0x51, 0xc3, 0xd8, 0x3e, 0xb5, 0x6b, 0x56, 0x82, 0x6d, 0x6c}
	binaryIDGlProgramUniform1fEXT                            = binary.ID{0xae, 0xe9, 0x91, 0x57, 0x18, 0x13, 0x69, 0x73, 0x4c, 0xda, 0xb8, 0x06, 0x03, 0xb9, 0x3f, 0x42, 0x24, 0x24, 0x09, 0x58}
	binaryIDGlProgramUniform1fv                              = binary.ID{0x69, 0x43, 0x5b, 0xdc, 0x12, 0xed, 0x4a, 0x55, 0x24, 0xd5, 0x31, 0x41, 0xb7, 0xc6, 0x34, 0xe9, 0x57, 0x16, 0xa4, 0x74}
	binaryIDGlProgramUniform1fvEXT                           = binary.ID{0x2d, 0xea, 0x7a, 0x87, 0xf8, 0x37, 0x85, 0x38, 0x6c, 0xa9, 0xb4, 0x4f, 0x1b, 0x05, 0xd4, 0x49, 0xd9, 0x88, 0x2a, 0xa4}
	binaryIDGlProgramUniform1i                               = binary.ID{0x62, 0xa0, 0xe2, 0xd9, 0x7e, 0xf7, 0xcc, 0xb4, 0x13, 0x65, 0x88, 0x70, 0x11, 0x2e, 0xdf, 0xf5, 0xd7, 0x46, 0x06, 0x7f}
	binaryIDGlProgramUniform1iEXT                            = binary.ID{0x9b, 0x4e, 0x65, 0xe8, 0x8c, 0x72, 0x5d, 0x5a, 0xc5, 0x39, 0x86, 0x4f, 0x28, 0xe8, 0x38, 0x85, 0xc1, 0x73, 0x27, 0x9e}
	binaryIDGlProgramUniform1iv                              = binary.ID{0x21, 0xa1, 0x7e, 0xf0, 0xe8, 0x2e, 0x87, 0xdd, 0x2e, 0x0f, 0x35, 0x67, 0x66, 0x14, 0xc3, 0xaf, 0x52, 0x17, 0x18, 0xd0}
	binaryIDGlProgramUniform1ivEXT                           = binary.ID{0x9c, 0xf1, 0xa9, 0x82, 0xbc, 0x18, 0x2a, 0xc0, 0x29, 0xc0, 0xc8, 0xff, 0x94, 0x67, 0xa7, 0xcd, 0x24, 0x44, 0xb4, 0x46}
	binaryIDGlProgramUniform1ui                              = binary.ID{0x5f, 0x1d, 0x26, 0x0b, 0xa8, 0x10, 0x08, 0x00, 0x3a, 0xea, 0x19, 0x14, 0xde, 0xe8, 0x1f, 0x23, 0x69, 0xef, 0x01, 0x6d}
	binaryIDGlProgramUniform1uiEXT                           = binary.ID{0xe3, 0x1f, 0x8b, 0x95, 0x37, 0x09, 0x8e, 0xb2, 0xc7, 0x89, 0xdd, 0x4e, 0xc0, 0x63, 0x13, 0x7b, 0xb2, 0x8b, 0x5a, 0x2b}
	binaryIDGlProgramUniform1uiv                             = binary.ID{0x00, 0x19, 0x38, 0x2c, 0xc6, 0x98, 0xe2, 0xbe, 0x38, 0x4a, 0xde, 0x54, 0xc5, 0xe2, 0x10, 0x94, 0xae, 0x65, 0x7f, 0x64}
	binaryIDGlProgramUniform1uivEXT                          = binary.ID{0xbd, 0xe0, 0x8a, 0x9e, 0x96, 0xd0, 0xe9, 0xf3, 0xa0, 0x25, 0x05, 0xca, 0x8b, 0xf0, 0x2d, 0x26, 0x09, 0x35, 0x04, 0xdf}
	binaryIDGlProgramUniform2f                               = binary.ID{0xfd, 0xf9, 0x56, 0x02, 0x6d, 0x3a, 0x30, 0x65, 0x4b, 0xac, 0x5c, 0x20, 0x19, 0xd3, 0x40, 0xf9, 0xff, 0x46, 0xc3, 0xcc}
	binaryIDGlProgramUniform2fEXT                            = binary.ID{0x4d, 0xee, 0x10, 0x8c, 0x0f, 0x9a, 0x85, 0x5d, 0x61, 0x8f, 0x85, 0xe7, 0xf5, 0xcd, 0x0d, 0x82, 0x9a, 0xa9, 0xbb, 0x17}
	binaryIDGlProgramUniform2fv                              = binary.ID{0xf9, 0x1a, 0x56, 0xe4, 0x42, 0x49, 0xc0, 0x74, 0x03, 0xca, 0xfb, 0x4f, 0xce, 0x24, 0x98, 0x47, 0x16, 0x45, 0x7c, 0x3c}
	binaryIDGlProgramUniform2fvEXT                           = binary.ID{0xc6, 0xb0, 0xaf, 0x8f, 0x8e, 0xd3, 0xf8, 0xaa, 0x87, 0x1c, 0xac, 0x79, 0xc4, 0xb1, 0x75, 0x77, 0x53, 0xd4, 0xc8, 0x6e}
	binaryIDGlProgramUniform2i                               = binary.ID{0xee, 0x91, 0x98, 0xf6, 0x73, 0x5b, 0x21, 0x0b, 0x72, 0x0a, 0x30, 0xee, 0xe8, 0x59, 0xce, 0xce, 0x85, 0x09, 0x89, 0x3f}
	binaryIDGlProgramUniform2iEXT                            = binary.ID{0x49, 0x53, 0x31, 0xfd, 0x9f, 0x27, 0x37, 0x0d, 0x21, 0x9a, 0xa4, 0x41, 0xe1, 0x8e, 0x93, 0x21, 0x86, 0xd6, 0xe6, 0x57}
	binaryIDGlProgramUniform2iv                              = binary.ID{0x0a, 0xdd, 0xab, 0xa0, 0x3b, 0x38, 0x3b, 0xbb, 0xb2, 0xbb, 0xa1, 0xa7, 0xc1, 0x6e, 0xaa, 0x13, 0x18, 0x18, 0x79, 0xf8}
	binaryIDGlProgramUniform2ivEXT                           = binary.ID{0xba, 0x05, 0xaf, 0xf5, 0x29, 0xcd, 0x76, 0x7e, 0x76, 0x15, 0x27, 0x2f, 0x56, 0xa5, 0xf8, 0xa9, 0xe7, 0x8c, 0x10, 0x93}
	binaryIDGlProgramUniform2ui                              = binary.ID{0xcb, 0x80, 0x7b, 0x37, 0x29, 0xb6, 0xbc, 0x74, 0x28, 0x8b, 0x16, 0xd7, 0x99, 0x6b, 0x9f, 0x60, 0xff, 0x1a, 0xf1, 0xc2}
	binaryIDGlProgramUniform2uiEXT                           = binary.ID{0x58, 0xdb, 0xbb, 0x8b, 0x2d, 0x24, 0x83, 0xc2, 0x74, 0xca, 0xa5, 0xde, 0x8c, 0x04, 0xfe, 0x24, 0x9a, 0x22, 0x00, 0xc5}
	binaryIDGlProgramUniform2uiv                             = binary.ID{0xa3, 0xaf, 0x58, 0x13, 0xfc, 0x7c, 0x26, 0x2f, 0x6f, 0xec, 0x73, 0xc6, 0x37, 0x9d, 0x2a, 0xda, 0xd0, 0xed, 0x71, 0x80}
	binaryIDGlProgramUniform2uivEXT                          = binary.ID{0xef, 0x47, 0xe4, 0x34, 0xbe, 0x3c, 0x92, 0x63, 0x30, 0xcf, 0xe1, 0xfe, 0x1e, 0x79, 0x8c, 0xa5, 0x3d, 0x41, 0x01, 0xe2}
	binaryIDGlProgramUniform3f                               = binary.ID{0x7b, 0xeb, 0x1a, 0x52, 0x01, 0x6a, 0x5b, 0x09, 0x3e, 0x94, 0x90, 0xbd, 0xc5, 0x4b, 0x29, 0x39, 0xea, 0x00, 0xf3, 0x63}
	binaryIDGlProgramUniform3fEXT                            = binary.ID{0x4f, 0x5d, 0x74, 0x63, 0x97, 0x75, 0x9b, 0x51, 0x09, 0x3a, 0xe8, 0x40, 0xb6, 0x08, 0xa8, 0xef, 0x31, 0xd7, 0x32, 0x1f}
	binaryIDGlProgramUniform3fv                              = binary.ID{0x05, 0xc0, 0x0b, 0xbf, 0xfd, 0xec, 0x29, 0xa9, 0xa8, 0x5f, 0xb4, 0xe1, 0xde, 0xa5, 0xca, 0x80, 0x3f, 0x99, 0xb7, 0xfe}
	binaryIDGlProgramUniform3fvEXT                           = binary.ID{0x96, 0x7c, 0x66, 0xa4, 0x73, 0x03, 0x8a, 0xba, 0x8e, 0x62, 0xae, 0x06, 0x65, 0x12, 0x15, 0x62, 0x31, 0x1e, 0x85, 0x2f}
	binaryIDGlProgramUniform3i                               = binary.ID{0x9a, 0xb8, 0xf8, 0xfe, 0x6c, 0x59, 0x7f, 0x09, 0x3d, 0x5c, 0x07, 0x7a, 0x90, 0x19, 0x40, 0x98, 0x43, 0xbc, 0xab, 0xa9}
	binaryIDGlProgramUniform3iEXT                            = binary.ID{0x55, 0x45, 0x38, 0xa2, 0x18, 0xde, 0x30, 0xce, 0xcc, 0x69, 0x1f, 0xba, 0x3e, 0x7f, 0x48, 0xaf, 0xbc, 0x4f, 0x61, 0x65}
	binaryIDGlProgramUniform3iv                              = binary.ID{0xa0, 0x8c, 0xec, 0x72, 0xbf, 0x0e, 0x1f, 0x30, 0xc2, 0x08, 0x7d, 0x6b, 0x12, 0xe4, 0x92, 0x0b, 0x88, 0x18, 0xa8, 0x7a}
	binaryIDGlProgramUniform3ivEXT                           = binary.ID{0x31, 0x24, 0x8b, 0xd3, 0xfc, 0xe0, 0x49, 0x8b, 0xd0, 0x40, 0x23, 0x89, 0x2c, 0xab, 0x9d, 0x47, 0x9d, 0xc5, 0x8c, 0xfd}
	binaryIDGlProgramUniform3ui                              = binary.ID{0xf9, 0x53, 0x9e, 0x99, 0x91, 0xdc, 0x1c, 0x7c, 0x39, 0xe3, 0xf5, 0xe9, 0x3c, 0x1c, 0x92, 0x96, 0xde, 0xa3, 0xa5, 0xe1}
	binaryIDGlProgramUniform3uiEXT                           = binary.ID{0x39, 0xe3, 0xfa, 0xeb, 0x4f, 0xd2, 0x6c, 0x0a, 0x06, 0x1d, 0x79, 0x54, 0x69, 0x15, 0x23, 0x17, 0xf2, 0x34, 0x29, 0xf8}
	binaryIDGlProgramUniform3uiv                             = binary.ID{0x46, 0xfe, 0x77, 0x64, 0xc9, 0xbe, 0x72, 0xa7, 0x26, 0xdd, 0x98, 0x5f, 0x8c, 0xd9, 0x7d, 0x13, 0xb4, 0x26, 0xb5, 0x57}
	binaryIDGlProgramUniform3uivEXT                          = binary.ID{0x04, 0xc2, 0xf0, 0x4a, 0x61, 0xcd, 0x46, 0x11, 0x98, 0x6e, 0xd7, 0xec, 0xbc, 0xb7, 0x5a, 0xde, 0xaa, 0x84, 0xac, 0x79}
	binaryIDGlProgramUniform4f                               = binary.ID{0x16, 0xf1, 0x2f, 0xe2, 0xdc, 0x67, 0x94, 0x89, 0x57, 0xe7, 0x97, 0x7c, 0x53, 0xfa, 0x60, 0x0c, 0x9d, 0x3f, 0xc5, 0xda}
	binaryIDGlProgramUniform4fEXT                            = binary.ID{0xef, 0x91, 0x36, 0x8d, 0xcf, 0x44, 0x80, 0x8e, 0x36, 0xd9, 0x0c, 0xbf, 0x6f, 0x1f, 0xf5, 0xb8, 0xe1, 0x39, 0x54, 0xb4}
	binaryIDGlProgramUniform4fv                              = binary.ID{0xfe, 0x29, 0x4f, 0x89, 0x77, 0x95, 0xbe, 0x3a, 0x2b, 0x7d, 0xf7, 0xd8, 0x48, 0x5f, 0x4a, 0x1d, 0x7a, 0xb4, 0x7e, 0xce}
	binaryIDGlProgramUniform4fvEXT                           = binary.ID{0x8f, 0x0e, 0xa6, 0x27, 0x91, 0xd1, 0xf9, 0x26, 0x49, 0x43, 0xf9, 0x81, 0x52, 0x81, 0x25, 0xe4, 0x9a, 0x4f, 0xbe, 0x45}
	binaryIDGlProgramUniform4i                               = binary.ID{0xab, 0x61, 0xcf, 0xa8, 0x44, 0xca, 0xe5, 0x34, 0x9a, 0xe0, 0x90, 0x32, 0xf3, 0xb3, 0xbb, 0x22, 0x8f, 0xb5, 0x29, 0x90}
	binaryIDGlProgramUniform4iEXT                            = binary.ID{0x7a, 0xbe, 0xe5, 0xdd, 0xbd, 0xe3, 0xed, 0x9c, 0xca, 0x1b, 0xbd, 0x89, 0xe8, 0x8a, 0xcc, 0x94, 0xaa, 0x84, 0xf3, 0xfb}
	binaryIDGlProgramUniform4iv                              = binary.ID{0x5e, 0xba, 0xbc, 0xaa, 0xe1, 0x23, 0x47, 0x56, 0x30, 0x8e, 0xc7, 0x2f, 0xc2, 0x39, 0x78, 0x1e, 0x1e, 0x2f, 0x92, 0xb2}
	binaryIDGlProgramUniform4ivEXT                           = binary.ID{0x14, 0x83, 0xcf, 0xb4, 0x4f, 0x65, 0x54, 0x7b, 0x69, 0xc3, 0xa0, 0x57, 0x35, 0x93, 0x14, 0x31, 0xd2, 0x48, 0x7c, 0x20}
	binaryIDGlProgramUniform4ui                              = binary.ID{0xd0, 0x68, 0x33, 0x69, 0x5c, 0x69, 0x2a, 0x21, 0xe8, 0x3d, 0x7a, 0xc4, 0x7d, 0xad, 0xc4, 0x9d, 0x42, 0x5b, 0x35, 0x3b}
	binaryIDGlProgramUniform4uiEXT                           = binary.ID{0x2d, 0x74, 0x78, 0x05, 0x9e, 0xd1, 0xbd, 0x44, 0x40, 0x94, 0xef, 0x1f, 0x30, 0xe4, 0x51, 0x05, 0x7d, 0xb4, 0xd2, 0x71}
	binaryIDGlProgramUniform4uiv                             = binary.ID{0x4d, 0x06, 0x5b, 0xfe, 0x54, 0x8e, 0x3d, 0xb8, 0xe0, 0x69, 0xa3, 0x06, 0xe7, 0x63, 0x14, 0xff, 0xd2, 0x2f, 0xc6, 0x10}
	binaryIDGlProgramUniform4uivEXT                          = binary.ID{0x2c, 0x5b, 0xad, 0x6f, 0xe2, 0x44, 0x53, 0x4c, 0x86, 0xb6, 0x0f, 0x0c, 0x7a, 0x94, 0xba, 0x39, 0xff, 0x79, 0x27, 0x07}
	binaryIDGlProgramUniformHandleui64NV                     = binary.ID{0x14, 0x5c, 0x76, 0x05, 0xef, 0x3f, 0xfe, 0xf7, 0x52, 0x19, 0x62, 0x4a, 0x4f, 0xba, 0x11, 0x8e, 0xe6, 0x85, 0xaa, 0x68}
	binaryIDGlProgramUniformHandleui64vNV                    = binary.ID{0x16, 0x8c, 0x1d, 0xc9, 0x9f, 0xe8, 0x22, 0x65, 0xe9, 0xcf, 0x5f, 0x22, 0xa7, 0xbe, 0x6f, 0xdc, 0x1b, 0xbd, 0x5b, 0xcc}
	binaryIDGlProgramUniformMatrix2fv                        = binary.ID{0xaa, 0x52, 0x19, 0x86, 0x9d, 0xbc, 0xf0, 0xb6, 0x6d, 0x77, 0xe1, 0xc4, 0xac, 0xd9, 0x62, 0xae, 0x96, 0x47, 0xbe, 0x5e}
	binaryIDGlProgramUniformMatrix2fvEXT                     = binary.ID{0x7d, 0xef, 0x50, 0xba, 0x8e, 0xe6, 0x9a, 0x2d, 0x13, 0xab, 0x84, 0x10, 0xcb, 0x2e, 0x5f, 0xf4, 0xea, 0x99, 0xe7, 0x3d}
	binaryIDGlProgramUniformMatrix2x3fv                      = binary.ID{0xab, 0x37, 0x4c, 0x52, 0x07, 0x96, 0x27, 0xf8, 0x22, 0xc2, 0xd5, 0xe0, 0xe7, 0x61, 0xd4, 0x19, 0xc1, 0xce, 0xae, 0x35}
	binaryIDGlProgramUniformMatrix2x3fvEXT                   = binary.ID{0x82, 0x66, 0xe9, 0x9e, 0x09, 0x78, 0x2e, 0x83, 0x34, 0xca, 0x0c, 0xb4, 0x34, 0xae, 0xa4, 0xca, 0x4e, 0xf5, 0xc2, 0x8c}
	binaryIDGlProgramUniformMatrix2x4fv                      = binary.ID{0x79, 0x4b, 0x60, 0xea, 0xd1, 0x5a, 0x85, 0x87, 0xf3, 0x8b, 0xbb, 0x87, 0x98, 0xba, 0x48, 0xb9, 0x9f, 0xf0, 0x20, 0xbe}
	binaryIDGlProgramUniformMatrix2x4fvEXT                   = binary.ID{0x25, 0x0b, 0x36, 0xa7, 0x7f, 0x3f, 0x50, 0x0a, 0x0d, 0xd6, 0xcb, 0x58, 0x36, 0xa3, 0x31, 0x18, 0x38, 0x60, 0xb6, 0x7f}
	binaryIDGlProgramUniformMatrix3fv                        = binary.ID{0xef, 0x88, 0x4c, 0x74, 0x15, 0xcd, 0x35, 0xdf, 0xa8, 0x2b, 0x43, 0x60, 0x16, 0x9e, 0x96, 0xf6, 0xd5, 0x99, 0x7e, 0x7d}
	binaryIDGlProgramUniformMatrix3fvEXT                     = binary.ID{0x46, 0x0c, 0xe4, 0x42, 0xc5, 0xd0, 0x0c, 0x16, 0xf3, 0xce, 0x65, 0x57, 0x31, 0x53, 0xcb, 0xd7, 0x0e, 0xba, 0x45, 0xbe}
	binaryIDGlProgramUniformMatrix3x2fv                      = binary.ID{0xa8, 0xdc, 0xe4, 0xbe, 0xf1, 0xcf, 0xf9, 0x57, 0x99, 0xd5, 0x1f, 0x33, 0x25, 0x65, 0x66, 0x78, 0xff, 0x24, 0x5d, 0xf6}
	binaryIDGlProgramUniformMatrix3x2fvEXT                   = binary.ID{0x78, 0x69, 0xf7, 0x79, 0xfe, 0xc8, 0x26, 0x47, 0x42, 0x4c, 0x3a, 0x79, 0xa8, 0x0c, 0xba, 0x96, 0xe6, 0x7e, 0xca, 0x26}
	binaryIDGlProgramUniformMatrix3x4fv                      = binary.ID{0x6f, 0x08, 0xf5, 0xcd, 0xcf, 0xef, 0x47, 0x72, 0xc9, 0xc7, 0x07, 0x0e, 0xd6, 0x4d, 0xb8, 0x2b, 0x21, 0x80, 0x65, 0xf0}
	binaryIDGlProgramUniformMatrix3x4fvEXT                   = binary.ID{0x1a, 0x69, 0x9b, 0xa9, 0xf6, 0xf3, 0x80, 0x6c, 0xf3, 0xf8, 0xe2, 0xdf, 0x52, 0x73, 0x22, 0x7e, 0x5c, 0x81, 0x2c, 0x65}
	binaryIDGlProgramUniformMatrix4fv                        = binary.ID{0xfc, 0xef, 0x13, 0x5c, 0x37, 0xe9, 0x77, 0x02, 0x44, 0x14, 0x68, 0xe8, 0x46, 0xdf, 0xf6, 0x3d, 0x23, 0x96, 0x51, 0x6d}
	binaryIDGlProgramUniformMatrix4fvEXT                     = binary.ID{0x46, 0xe6, 0x7d, 0x19, 0x2d, 0xeb, 0xc7, 0x05, 0xf0, 0xf5, 0xf3, 0xed, 0x94, 0x0b, 0x5b, 0x8e, 0x15, 0xe7, 0xde, 0x3a}
	binaryIDGlProgramUniformMatrix4x2fv                      = binary.ID{0xad, 0x7b, 0x7d, 0xd2, 0xe8, 0x3e, 0xd5, 0x4b, 0x66, 0x64, 0xe3, 0x7b, 0xd6, 0xf7, 0xbf, 0x42, 0xfe, 0xd7, 0xae, 0x80}
	binaryIDGlProgramUniformMatrix4x2fvEXT                   = binary.ID{0xb9, 0x8c, 0x3d, 0xf7, 0x76, 0xf7, 0xbe, 0xf9, 0x9d, 0x36, 0x26, 0xf8, 0x9e, 0xc6, 0x69, 0xfb, 0xfc, 0xb7, 0x74, 0x9d}
	binaryIDGlProgramUniformMatrix4x3fv                      = binary.ID{0x72, 0xcb, 0x1f, 0x0a, 0xbe, 0x73, 0x29, 0x95, 0x41, 0xe9, 0xfc, 0xd1, 0x84, 0x38, 0xee, 0x1c, 0x74, 0xc4, 0x65, 0x07}
	binaryIDGlProgramUniformMatrix4x3fvEXT                   = binary.ID{0xe6, 0x8f, 0x11, 0xef, 0x7f, 0x63, 0x02, 0x7e, 0x16, 0x30, 0x89, 0xb2, 0xd8, 0xf5, 0x3d, 0x5f, 0x2f, 0xfa, 0x8b, 0x13}
	binaryIDGlPushDebugGroupKHR                              = binary.ID{0xaa, 0xad, 0xf6, 0x49, 0x5c, 0xde, 0xa9, 0xac, 0x02, 0x01, 0x29, 0xd1, 0x00, 0x12, 0x83, 0xfd, 0x7d, 0xbf, 0x7a, 0x2d}
	binaryIDGlPushGroupMarkerEXT                             = binary.ID{0x96, 0xc0, 0xda, 0xa0, 0x66, 0x00, 0x07, 0x43, 0xbb, 0x10, 0x3c, 0x72, 0xc3, 0x51, 0x78, 0x69, 0x1e, 0xa0, 0x43, 0x84}
	binaryIDGlQueryCounterEXT                                = binary.ID{0x88, 0xcc, 0x38, 0xb0, 0xd2, 0x9a, 0xbd, 0x37, 0xd7, 0x6f, 0x4f, 0xb3, 0xba, 0x95, 0xd8, 0x6a, 0xda, 0x18, 0x5e, 0x18}
	binaryIDGlRasterSamplesEXT                               = binary.ID{0x5d, 0x7e, 0x65, 0x24, 0xcb, 0xab, 0x5a, 0xed, 0x90, 0x07, 0x1e, 0x9f, 0xa3, 0xad, 0x53, 0x12, 0x1d, 0x8c, 0x64, 0xff}
	binaryIDGlReadBuffer                                     = binary.ID{0x35, 0x3d, 0xfb, 0x8e, 0x83, 0x64, 0x33, 0x55, 0x7b, 0xec, 0x57, 0xec, 0xc3, 0x39, 0x30, 0x63, 0xde, 0xab, 0xa1, 0x43}
	binaryIDGlReadBufferIndexedEXT                           = binary.ID{0x42, 0xd5, 0xb6, 0xda, 0xd7, 0x75, 0x93, 0xc7, 0xc4, 0x16, 0x8b, 0xcb, 0x42, 0x5b, 0xed, 0xab, 0x56, 0x48, 0x0a, 0x38}
	binaryIDGlReadBufferNV                                   = binary.ID{0x4b, 0xa9, 0x27, 0x0c, 0x96, 0xe7, 0xe3, 0x8d, 0x10, 0xb4, 0x15, 0x1e, 0x02, 0x8f, 0x06, 0x0e, 0x13, 0xdc, 0xe9, 0xf6}
	binaryIDGlReadPixels                                     = binary.ID{0x1b, 0x22, 0x34, 0xf6, 0x26, 0x2f, 0xf1, 0x3e, 0xf1, 0x4b, 0x12, 0xd5, 0xe5, 0x6e, 0x69, 0xc9, 0xb2, 0xaf, 0xa6, 0x3a}
	binaryIDGlReadnPixelsEXT                                 = binary.ID{0x30, 0x8f, 0x1c, 0x57, 0x89, 0xeb, 0x28, 0xe0, 0x34, 0x59, 0x00, 0xdd, 0x64, 0x26, 0x3c, 0x77, 0x99, 0xe7, 0xe3, 0xa9}
	binaryIDGlReadnPixelsKHR                                 = binary.ID{0xef, 0xef, 0xff, 0xf9, 0xa4, 0xa6, 0xdf, 0xd9, 0xbf, 0xef, 0x2a, 0x7a, 0xee, 0x47, 0x18, 0xa6, 0x31, 0x5f, 0x37, 0x58}
	binaryIDGlReleaseShaderCompiler                          = binary.ID{0x75, 0x57, 0x32, 0x6e, 0x7b, 0x73, 0x9d, 0x61, 0x34, 0xf4, 0xfe, 0x45, 0xb6, 0xb2, 0x1d, 0x6e, 0xd0, 0xab, 0xbb, 0x78}
	binaryIDGlRenderbufferStorage                            = binary.ID{0x96, 0xb6, 0xf4, 0xaf, 0x4d, 0x15, 0xec, 0xb2, 0x04, 0xce, 0xc2, 0xc5, 0x5e, 0xda, 0xf2, 0xf4, 0xd8, 0x06, 0xdb, 0x09}
	binaryIDGlRenderbufferStorageMultisample                 = binary.ID{0xcc, 0x4f, 0x6f, 0xa6, 0xfd, 0xb1, 0x59, 0x1f, 0x21, 0x6f, 0xfc, 0x8c, 0xf8, 0x45, 0x53, 0x0f, 0x26, 0x58, 0x65, 0xd0}
	binaryIDGlRenderbufferStorageMultisampleANGLE            = binary.ID{0x6f, 0x2c, 0x51, 0x51, 0xe1, 0xab, 0x40, 0x51, 0xf4, 0x31, 0x04, 0x5a, 0x18, 0x54, 0x91, 0xdf, 0x72, 0xf2, 0x2f, 0x4b}
	binaryIDGlRenderbufferStorageMultisampleAPPLE            = binary.ID{0x7c, 0x58, 0x85, 0x21, 0x8a, 0x9d, 0x64, 0x9e, 0xd5, 0x4f, 0x75, 0x79, 0x01, 0xb0, 0xe9, 0x1b, 0xe9, 0x01, 0xc2, 0x88}
	binaryIDGlRenderbufferStorageMultisampleEXT              = binary.ID{0xd5, 0xe8, 0x69, 0xc5, 0xab, 0xd6, 0x42, 0x95, 0xe2, 0x38, 0xd5, 0x8b, 0x6e, 0xac, 0x9b, 0x5a, 0x1d, 0x76, 0x7d, 0xcd}
	binaryIDGlRenderbufferStorageMultisampleIMG              = binary.ID{0xb4, 0xb2, 0x11, 0x7d, 0x3b, 0x90, 0x56, 0x32, 0x5b, 0x76, 0xe6, 0xc1, 0x14, 0x79, 0xc4, 0x9c, 0x7c, 0x4f, 0xe4, 0x53}
	binaryIDGlRenderbufferStorageMultisampleNV               = binary.ID{0xb4, 0x5f, 0x41, 0x98, 0x27, 0x42, 0x6c, 0xc0, 0xa7, 0xe8, 0xa5, 0x1a, 0xd3, 0xdc, 0x93, 0xf4, 0x04, 0x95, 0xfe, 0xbd}
	binaryIDGlResolveDepthValuesNV                           = binary.ID{0x1f, 0x25, 0xbe, 0xc8, 0xff, 0xbe, 0x1b, 0x80, 0xf7, 0xdb, 0x8a, 0x7f, 0x33, 0xf6, 0x96, 0x73, 0x19, 0xd8, 0xaf, 0xe6}
	binaryIDGlResolveMultisampleFramebufferAPPLE             = binary.ID{0xfa, 0xaf, 0x24, 0x40, 0x87, 0xc2, 0xce, 0x82, 0x78, 0x08, 0x1c, 0xc8, 0xaa, 0x86, 0xc9, 0xad, 0x72, 0xbe, 0x58, 0xd7}
	binaryIDGlResumeTransformFeedback                        = binary.ID{0x78, 0x30, 0xbd, 0xa6, 0xf3, 0xcd, 0xd9, 0xb2, 0x78, 0x6d, 0x4e, 0x69, 0x2e, 0x69, 0xcf, 0xe5, 0x4f, 0x78, 0xd8, 0x21}
	binaryIDGlSampleCoverage                                 = binary.ID{0x8f, 0x2d, 0x0f, 0x2a, 0x05, 0x41, 0x30, 0x62, 0xd9, 0x60, 0x92, 0x3b, 0x02, 0x58, 0xdf, 0x37, 0x82, 0xa1, 0xb7, 0xbd}
	binaryIDGlSampleMaski                                    = binary.ID{0xf9, 0x62, 0x3a, 0x77, 0xe0, 0xab, 0x12, 0xac, 0xae, 0x9c, 0x9d, 0x2a, 0x7c, 0x46, 0x08, 0xca, 0xe1, 0x25, 0x23, 0x8f}
	binaryIDGlSamplerParameterIivEXT                         = binary.ID{0xb2, 0x2e, 0x2b, 0x5e, 0x97, 0xb8, 0x67, 0xcd, 0x21, 0x4c, 0xf9, 0xc6, 0x05, 0x27, 0x3a, 0xcc, 0x3e, 0x6e, 0x00, 0x0c}
	binaryIDGlSamplerParameterIivOES                         = binary.ID{0x35, 0xb2, 0x07, 0x23, 0xe3, 0xde, 0x9b, 0xad, 0xaf, 0x52, 0x20, 0x75, 0xe1, 0x09, 0x50, 0xbe, 0x60, 0x31, 0x10, 0xc8}
	binaryIDGlSamplerParameterIuivEXT                        = binary.ID{0x6d, 0xe3, 0xca, 0x29, 0x0e, 0x21, 0x75, 0x1e, 0xce, 0x57, 0x2d, 0x75, 0x97, 0xbd, 0x54, 0x3b, 0x78, 0x7f, 0xff, 0xa5}
	binaryIDGlSamplerParameterIuivOES                        = binary.ID{0x57, 0x02, 0xc2, 0x53, 0x97, 0xca, 0x5c, 0xc8, 0x8b, 0xd3, 0x0c, 0x06, 0xa1, 0xa9, 0x09, 0x94, 0xb5, 0xec, 0xc7, 0x56}
	binaryIDGlSamplerParameterf                              = binary.ID{0x67, 0x0e, 0xff, 0x85, 0x6c, 0xe4, 0x45, 0xaa, 0x5d, 0x5c, 0x52, 0xdb, 0x5d, 0x61, 0xdb, 0x38, 0x4a, 0xbd, 0x15, 0x48}
	binaryIDGlSamplerParameterfv                             = binary.ID{0xec, 0x5e, 0x36, 0xa9, 0x83, 0x87, 0x7d, 0x05, 0x62, 0xb8, 0x87, 0x1c, 0x01, 0x90, 0xe4, 0x25, 0x36, 0x6f, 0x19, 0xc6}
	binaryIDGlSamplerParameteri                              = binary.ID{0xeb, 0x5d, 0xa4, 0x8b, 0x32, 0x17, 0x54, 0xa9, 0xd4, 0x0a, 0xf1, 0x81, 0x81, 0x6e, 0x3c, 0x18, 0xde, 0xd4, 0xd4, 0xd5}
	binaryIDGlSamplerParameteriv                             = binary.ID{0xf1, 0x59, 0xdf, 0xc1, 0x8c, 0xdb, 0x25, 0x15, 0xbd, 0x5d, 0xf8, 0x97, 0x0b, 0x86, 0x98, 0xc2, 0xa4, 0x29, 0x35, 0x13}
	binaryIDGlScissor                                        = binary.ID{0x5d, 0xe5, 0xc5, 0xe0, 0xb3, 0x81, 0xab, 0xa5, 0x49, 0x73, 0xaa, 0x0c, 0xac, 0xb2, 0x3a, 0x59, 0x75, 0x3c, 0x81, 0x5c}
	binaryIDGlScissorArrayvNV                                = binary.ID{0x53, 0x72, 0x68, 0x38, 0xf0, 0xba, 0x6a, 0x26, 0xf7, 0x55, 0x2a, 0x88, 0xae, 0x2b, 0xb6, 0x95, 0x9a, 0xb6, 0xaa, 0xd1}
	binaryIDGlScissorIndexedNV                               = binary.ID{0x0f, 0x18, 0x42, 0x60, 0xf2, 0xa7, 0x5a, 0x8e, 0x2f, 0xc0, 0x95, 0x09, 0x9e, 0x8a, 0x08, 0xe0, 0x80, 0x55, 0xfc, 0xc1}
	binaryIDGlScissorIndexedvNV                              = binary.ID{0x67, 0xb5, 0x67, 0x82, 0xbf, 0x87, 0x1e, 0x4a, 0x13, 0xdc, 0xf9, 0x0e, 0x01, 0xe0, 0xa4, 0x70, 0x47, 0x9d, 0x69, 0xb7}
	binaryIDGlSelectPerfMonitorCountersAMD                   = binary.ID{0x56, 0x60, 0xaf, 0xa6, 0x22, 0x62, 0xe5, 0xe7, 0x71, 0x2b, 0xd4, 0xec, 0x9d, 0x43, 0x1e, 0x87, 0x54, 0x09, 0x56, 0x0f}
	binaryIDGlSetFenceNV                                     = binary.ID{0x1d, 0x7f, 0x53, 0x31, 0x6a, 0xd7, 0xe3, 0x4d, 0x34, 0xa6, 0xcf, 0xa0, 0x9d, 0x71, 0xe5, 0x9b, 0xcc, 0xc1, 0xbd, 0x4f}
	binaryIDShaderIdᶜᵖ                                       = binary.ID{0xa8, 0xd0, 0xe6, 0x52, 0xb7, 0x1b, 0xa4, 0xd0, 0xa9, 0x83, 0x04, 0x34, 0x15, 0x15, 0x04, 0x58, 0x1f, 0x94, 0x75, 0x23}
	binaryIDGlShaderBinary                                   = binary.ID{0xf3, 0xa3, 0xea, 0x2a, 0x16, 0xdf, 0x9d, 0x91, 0x9c, 0x2c, 0x67, 0xbe, 0x1c, 0x0d, 0xcf, 0x9f, 0x21, 0x43, 0x4a, 0xd6}
	binaryIDGlShaderSource                                   = binary.ID{0xf7, 0x67, 0xef, 0x10, 0xd1, 0xd3, 0x93, 0x13, 0xd2, 0x61, 0xf6, 0x29, 0x35, 0xd4, 0x5b, 0xc9, 0x36, 0xf6, 0x9f, 0x83}
	binaryIDGlStartTilingQCOM                                = binary.ID{0x84, 0xee, 0x8b, 0x1b, 0x6f, 0x75, 0xa8, 0xb3, 0x8e, 0x96, 0xc1, 0x14, 0xe2, 0xf4, 0x2c, 0xd3, 0xd4, 0xd8, 0xc6, 0xbb}
	binaryIDGlStencilFillPathInstancedNV                     = binary.ID{0x69, 0x32, 0xfd, 0x0f, 0x87, 0x45, 0xbd, 0xcd, 0xa5, 0x44, 0xb1, 0x8d, 0x61, 0x27, 0xdc, 0x5e, 0x94, 0x2a, 0x19, 0x89}
	binaryIDGlStencilFillPathNV                              = binary.ID{0x1d, 0x01, 0x26, 0x2b, 0xd7, 0x5b, 0xfa, 0x65, 0x55, 0x2a, 0xdb, 0x40, 0xf8, 0xf8, 0xfc, 0x64, 0xe2, 0x5f, 0xac, 0xdb}
	binaryIDGlStencilFunc                                    = binary.ID{0xad, 0x4c, 0x6c, 0xd9, 0xc3, 0x63, 0x4b, 0x94, 0x1b, 0x2f, 0x8d, 0x4a, 0xd7, 0x55, 0xf8, 0x48, 0x3a, 0x99, 0x50, 0xde}
	binaryIDGlStencilFuncSeparate                            = binary.ID{0xc3, 0x99, 0x59, 0x3a, 0x2e, 0x84, 0xc6, 0x3d, 0x39, 0xe2, 0x7b, 0xa2, 0x79, 0x10, 0x73, 0x78, 0x11, 0xdc, 0xae, 0x23}
	binaryIDGlStencilMask                                    = binary.ID{0xb1, 0xd3, 0x70, 0xe6, 0x99, 0x75, 0x81, 0x9e, 0xe7, 0x10, 0x95, 0xbe, 0xa9, 0xc0, 0xa1, 0x16, 0x45, 0xf4, 0x43, 0xc5}
	binaryIDGlStencilMaskSeparate                            = binary.ID{0x3d, 0xa1, 0x14, 0xa4, 0x1b, 0x5f, 0x10, 0xe4, 0x43, 0x5e, 0xe1, 0x4f, 0xed, 0x01, 0x32, 0x87, 0xee, 0x18, 0x49, 0x04}
	binaryIDGlStencilOp                                      = binary.ID{0xe2, 0x31, 0x18, 0xf6, 0x65, 0x4c, 0x6f, 0x1f, 0x0d, 0x0b, 0x1f, 0x3c, 0xab, 0x3e, 0x45, 0x6c, 0x9f, 0xf4, 0x4c, 0x70}
	binaryIDGlStencilOpSeparate                              = binary.ID{0xa0, 0x11, 0x77, 0x8d, 0xd9, 0xd5, 0xb2, 0x0f, 0x80, 0x49, 0xfb, 0xa7, 0xa0, 0x3a, 0x8d, 0xc0, 0x43, 0x62, 0x45, 0x84}
	binaryIDGlStencilStrokePathInstancedNV                   = binary.ID{0x00, 0x3f, 0x27, 0x0e, 0x70, 0x2d, 0x97, 0x73, 0x0d, 0xcd, 0xd4, 0x6d, 0xbf, 0x5c, 0xc4, 0xbd, 0xe9, 0x2e, 0xdb, 0xea}
	binaryIDGlStencilStrokePathNV                            = binary.ID{0x9c, 0xc2, 0x91, 0xa7, 0xe0, 0x1e, 0x05, 0xf9, 0x95, 0x96, 0x48, 0xee, 0xa8, 0x8f, 0x5d, 0x5f, 0xd2, 0x75, 0x51, 0x2b}
	binaryIDGlStencilThenCoverFillPathInstancedNV            = binary.ID{0xc2, 0x31, 0x37, 0x12, 0x52, 0x1a, 0x40, 0x09, 0xb8, 0x90, 0xba, 0xe5, 0xe9, 0xca, 0xaf, 0x26, 0x51, 0x2e, 0xd1, 0x71}
	binaryIDGlStencilThenCoverFillPathNV                     = binary.ID{0xed, 0x58, 0x50, 0xe4, 0x0d, 0x24, 0x96, 0x96, 0x61, 0x52, 0xd4, 0xe2, 0x00, 0x0d, 0x95, 0xd8, 0xc5, 0x71, 0x58, 0x97}
	binaryIDGlStencilThenCoverStrokePathInstancedNV          = binary.ID{0xe5, 0xb9, 0x2d, 0x04, 0x48, 0x60, 0xfd, 0x89, 0xeb, 0xc8, 0x26, 0xf5, 0xdd, 0xe2, 0xbf, 0xa0, 0x6d, 0x47, 0x0a, 0x1a}
	binaryIDGlStencilThenCoverStrokePathNV                   = binary.ID{0x8f, 0x0b, 0x78, 0x6a, 0x8a, 0x54, 0xf8, 0x5d, 0xa7, 0x73, 0xb4, 0xdd, 0x7f, 0xf2, 0xdb, 0x9e, 0x07, 0xd7, 0x62, 0x12}
	binaryIDGlSubpixelPrecisionBiasNV                        = binary.ID{0xea, 0x0f, 0x84, 0x6c, 0x1d, 0x16, 0xbf, 0x0a, 0xe7, 0xf2, 0xc7, 0x5e, 0xb9, 0xc6, 0xa9, 0x34, 0x88, 0x94, 0x0e, 0x1e}
	binaryIDGlTestFenceNV                                    = binary.ID{0xda, 0x0f, 0xc7, 0xdc, 0x07, 0xa5, 0x55, 0xac, 0xfd, 0x2e, 0xdd, 0xa6, 0xc0, 0xad, 0x68, 0xe6, 0x1b, 0x46, 0xf1, 0x50}
	binaryIDGlTexBufferEXT                                   = binary.ID{0x72, 0x28, 0xab, 0xf2, 0xe5, 0xc4, 0x5f, 0x56, 0xef, 0xd4, 0x9b, 0xcd, 0x2f, 0xa8, 0x59, 0x2b, 0xa8, 0x5a, 0x11, 0xb4}
	binaryIDGlTexBufferOES                                   = binary.ID{0x05, 0x46, 0xa0, 0x1b, 0x01, 0xd9, 0xd8, 0xe5, 0xae, 0x0b, 0x26, 0x4a, 0x52, 0xd2, 0x16, 0xc0, 0xdc, 0x8d, 0x1b, 0x03}
	binaryIDGlTexBufferRangeEXT                              = binary.ID{0x8b, 0x16, 0x65, 0x06, 0xa7, 0xfa, 0x97, 0xfc, 0xfb, 0x97, 0xe1, 0x00, 0xd8, 0x72, 0xa6, 0x49, 0x7f, 0x2f, 0xdb, 0x3b}
	binaryIDGlTexBufferRangeOES                              = binary.ID{0xd8, 0xff, 0xf0, 0x4a, 0x73, 0x92, 0xd8, 0xf8, 0xc9, 0x3f, 0xd1, 0x95, 0x7c, 0x2f, 0xf6, 0xd5, 0x7b, 0xa0, 0x4c, 0x4a}
	binaryIDGlTexImage2D                                     = binary.ID{0x89, 0x8f, 0x0f, 0x2d, 0x48, 0x7d, 0xad, 0x43, 0x5a, 0x31, 0x7e, 0xc3, 0xd9, 0x84, 0xe4, 0x4b, 0x9e, 0xa5, 0x79, 0x64}
	binaryIDGlTexImage3D                                     = binary.ID{0x1d, 0xc6, 0x86, 0xc5, 0x6e, 0xea, 0x02, 0xf0, 0x1b, 0x3f, 0x63, 0xac, 0x2e, 0x88, 0xc4, 0x46, 0x74, 0xf2, 0xf2, 0xda}
	binaryIDGlTexImage3DOES                                  = binary.ID{0x7d, 0xb5, 0x38, 0xa3, 0x85, 0xaf, 0xdc, 0x8a, 0xd2, 0x72, 0xa0, 0x41, 0x19, 0x9c, 0x4d, 0xfd, 0x41, 0x5d, 0x00, 0x5b}
	binaryIDGlTexPageCommitmentARB                           = binary.ID{0x2c, 0x23, 0x03, 0x25, 0x39, 0xdd, 0x68, 0xdf, 0xec, 0x7e, 0xb8, 0xe9, 0x9a, 0x15, 0x7f, 0xeb, 0xa3, 0xf5, 0x5f, 0x28}
	binaryIDGlTexParameterIivEXT                             = binary.ID{0x42, 0x30, 0x01, 0xcb, 0x92, 0x45, 0xd6, 0xd2, 0x0b, 0x1e, 0x2a, 0xd9, 0x22, 0x67, 0x70, 0x83, 0x46, 0x69, 0x28, 0x49}
	binaryIDGlTexParameterIivOES                             = binary.ID{0xfd, 0x38, 0x82, 0xf5, 0x20, 0x5b, 0x56, 0x98, 0xe7, 0x51, 0xc9, 0xca, 0x79, 0xb9, 0xa7, 0xf3, 0xfe, 0x4a, 0x77, 0x9c}
	binaryIDGlTexParameterIuivEXT                            = binary.ID{0x55, 0x33, 0xa2, 0xe6, 0xed, 0xdc, 0x82, 0x3d, 0x7f, 0xb4, 0x2e, 0x0e, 0x62, 0x28, 0xbf, 0x83, 0x67, 0x22, 0xcb, 0x5b}
	binaryIDGlTexParameterIuivOES                            = binary.ID{0x80, 0x97, 0xb0, 0x65, 0x0f, 0xdb, 0xcd, 0x3a, 0xcf, 0x86, 0xac, 0x45, 0x17, 0xa7, 0x50, 0x9e, 0x50, 0x80, 0xf6, 0x30}
	binaryIDGlTexParameterf                                  = binary.ID{0x96, 0xb9, 0x4b, 0x9e, 0x9a, 0x52, 0xb2, 0x8c, 0xaa, 0x77, 0xa3, 0x3d, 0x0f, 0x3d, 0x13, 0x21, 0x7c, 0xf1, 0x19, 0x94}
	binaryIDGlTexParameterfv                                 = binary.ID{0x57, 0x2d, 0x9a, 0xdb, 0x03, 0x6b, 0x89, 0x55, 0x85, 0x6a, 0xae, 0x44, 0xc3, 0x99, 0x84, 0xfc, 0x4c, 0xad, 0x23, 0xff}
	binaryIDGlTexParameteri                                  = binary.ID{0xbb, 0x8f, 0x42, 0xc0, 0xc0, 0xea, 0xac, 0x2e, 0xfc, 0x97, 0x48, 0xd6, 0x76, 0x38, 0x0a, 0xb4, 0x29, 0x34, 0xe6, 0x2d}
	binaryIDGlTexParameteriv                                 = binary.ID{0xf9, 0x05, 0x3c, 0x49, 0x05, 0x72, 0xb2, 0x9f, 0x85, 0xb3, 0xec, 0xd8, 0x85, 0x4d, 0xca, 0x8c, 0xf0, 0x7c, 0xd5, 0xb3}
	binaryIDGlTexStorage1DEXT                                = binary.ID{0x1f, 0xd1, 0x47, 0x0d, 0x75, 0x0d, 0x02, 0x29, 0xd9, 0x31, 0x62, 0x0e, 0x19, 0x51, 0x30, 0x0e, 0x3b, 0x79, 0x97, 0xeb}
	binaryIDGlTexStorage2D                                   = binary.ID{0x7d, 0x1f, 0x77, 0xdd, 0xfe, 0xfe, 0xe9, 0xfa, 0x6e, 0xf5, 0x32, 0x63, 0xb5, 0xcc, 0x0b, 0x54, 0xb4, 0x8b, 0x74, 0x6b}
	binaryIDGlTexStorage2DEXT                                = binary.ID{0x6b, 0xd4, 0x60, 0x2b, 0x68, 0xaa, 0x02, 0x00, 0x5d, 0x5f, 0x44, 0x2b, 0xad, 0x3e, 0xd5, 0xbc, 0x60, 0x2c, 0xde, 0xc8}
	binaryIDGlTexStorage2DMultisample                        = binary.ID{0xe8, 0xc6, 0x53, 0x74, 0xe6, 0x8d, 0x8a, 0x7d, 0x0c, 0x03, 0xf3, 0xc0, 0xad, 0x68, 0xea, 0x00, 0xf5, 0x52, 0x06, 0xe7}
	binaryIDGlTexStorage3D                                   = binary.ID{0x04, 0x75, 0xa6, 0xae, 0x40, 0x93, 0x6d, 0x7e, 0x2f, 0x3d, 0xc1, 0xac, 0xa7, 0xde, 0x67, 0x40, 0x6b, 0x94, 0x35, 0x9c}
	binaryIDGlTexStorage3DEXT                                = binary.ID{0x38, 0x56, 0x7f, 0x63, 0xec, 0x2c, 0x5e, 0x58, 0x93, 0x55, 0x4e, 0xed, 0x2e, 0xb3, 0x31, 0x97, 0x37, 0x7d, 0xb0, 0x48}
	binaryIDGlTexStorage3DMultisampleOES                     = binary.ID{0x81, 0xea, 0x89, 0x94, 0x80, 0xbc, 0x28, 0x35, 0x70, 0xbb, 0x03, 0xb7, 0xf8, 0x3a, 0x60, 0xc1, 0x21, 0xfa, 0xb1, 0x45}
	binaryIDGlTexSubImage2D                                  = binary.ID{0xaa, 0xcc, 0xd8, 0xe5, 0x31, 0xe2, 0xeb, 0x33, 0x88, 0x45, 0xb2, 0xe5, 0x2a, 0xfa, 0xa1, 0xf4, 0xe3, 0x82, 0x5b, 0xd5}
	binaryIDGlTexSubImage3D                                  = binary.ID{0x2e, 0x73, 0xa8, 0xe5, 0xe8, 0xae, 0xbf, 0x0e, 0xb7, 0x53, 0xa8, 0x6e, 0xa0, 0xf7, 0xcd, 0x68, 0xd7, 0xc0, 0x00, 0x06}
	binaryIDGlTexSubImage3DOES                               = binary.ID{0x49, 0x4e, 0x1c, 0xec, 0x40, 0xa4, 0x72, 0xdc, 0x61, 0x9f, 0x30, 0x18, 0x01, 0x44, 0x63, 0x26, 0xe6, 0xf7, 0x26, 0xf0}
	binaryIDGlTextureStorage1DEXT                            = binary.ID{0x3d, 0x8f, 0xdc, 0x91, 0x23, 0xda, 0xa1, 0x5f, 0x87, 0xc3, 0x90, 0x4f, 0x1d, 0x3b, 0xf6, 0x62, 0x98, 0x47, 0x82, 0x3f}
	binaryIDGlTextureStorage2DEXT                            = binary.ID{0xe2, 0x7d, 0x7b, 0xaf, 0x81, 0x44, 0x32, 0x28, 0x63, 0xbe, 0xd8, 0xe5, 0x10, 0x4a, 0x3f, 0x75, 0x99, 0x55, 0x7d, 0x9b}
	binaryIDGlTextureStorage3DEXT                            = binary.ID{0x1f, 0x2e, 0x8e, 0x19, 0xa9, 0x93, 0xbd, 0x67, 0x8b, 0x3d, 0x67, 0xaa, 0xac, 0xc7, 0x1e, 0x12, 0xa6, 0xd9, 0xdd, 0xe6}
	binaryIDGlTextureViewEXT                                 = binary.ID{0x68, 0x09, 0x61, 0x2a, 0x65, 0x11, 0x82, 0x97, 0x1e, 0xf0, 0x17, 0xad, 0x76, 0x36, 0x8f, 0x8d, 0xb0, 0x58, 0x79, 0xcf}
	binaryIDGlTextureViewOES                                 = binary.ID{0xd7, 0x7f, 0xce, 0x58, 0xfe, 0x43, 0x89, 0xde, 0xfa, 0x37, 0x2a, 0x65, 0x92, 0x42, 0xb4, 0x78, 0xd6, 0x46, 0xfc, 0x05}
	binaryIDGlTransformFeedbackVaryings                      = binary.ID{0x05, 0x90, 0x3c, 0x9d, 0xe0, 0xcf, 0xeb, 0x1b, 0x5f, 0xd8, 0x15, 0xed, 0x5d, 0xe3, 0xdb, 0xbc, 0xfd, 0x52, 0x9e, 0x10}
	binaryIDGlTransformPathNV                                = binary.ID{0xe1, 0x50, 0x73, 0xb5, 0xbe, 0xe9, 0x5e, 0x36, 0xc8, 0xbe, 0x3f, 0x47, 0xe0, 0x1e, 0xe9, 0xf5, 0x22, 0xfb, 0xba, 0xd5}
	binaryIDGlUniform1f                                      = binary.ID{0x42, 0xca, 0xf3, 0x32, 0xaa, 0x89, 0x92, 0x1e, 0x61, 0x44, 0x80, 0xdb, 0xb6, 0xfe, 0x96, 0x3e, 0x5e, 0x70, 0x89, 0xac}
	binaryIDGlUniform1fv                                     = binary.ID{0xae, 0x33, 0x65, 0x0e, 0x08, 0x5e, 0xc1, 0x6d, 0x32, 0xa8, 0x27, 0x34, 0x37, 0x8a, 0xb0, 0x9d, 0x79, 0x13, 0xa0, 0x2d}
	binaryIDGlUniform1i                                      = binary.ID{0xcf, 0x50, 0xc7, 0x1d, 0x64, 0xc9, 0x73, 0xfe, 0x85, 0xd0, 0x29, 0x27, 0x6b, 0x85, 0xa8, 0xdb, 0xd7, 0xf2, 0x5a, 0xa0}
	binaryIDGlUniform1iv                                     = binary.ID{0xbb, 0xbc, 0xcf, 0xe9, 0xc6, 0x93, 0x5e, 0xea, 0x2c, 0x97, 0x8e, 0x17, 0x71, 0x99, 0x67, 0x50, 0x3e, 0x2c, 0x4d, 0x20}
	binaryIDGlUniform1ui                                     = binary.ID{0x2e, 0xc6, 0x29, 0x1a, 0x31, 0xca, 0x42, 0x34, 0xc7, 0x96, 0x01, 0x4e, 0xb5, 0x64, 0x94, 0x80, 0xf2, 0x8d, 0x59, 0x33}
	binaryIDGlUniform1uiv                                    = binary.ID{0x7e, 0x3e, 0xba, 0x97, 0x02, 0x28, 0x6c, 0xdd, 0x8f, 0x7b, 0x28, 0x0a, 0xa2, 0xee, 0xab, 0x9d, 0xaa, 0xd4, 0x3e, 0xab}
	binaryIDGlUniform2f                                      = binary.ID{0xc5, 0x77, 0x1f, 0xb7, 0x87, 0xd2, 0x21, 0xd6, 0x1d, 0x3c, 0x42, 0xea, 0xc0, 0xcc, 0x34, 0x67, 0x97, 0x52, 0x08, 0x0e}
	binaryIDGlUniform2fv                                     = binary.ID{0xc7, 0x22, 0x25, 0x97, 0x77, 0x22, 0x8f, 0x1a, 0xa0, 0x29, 0xbe, 0x9c, 0x90, 0x49, 0x9a, 0x32, 0xfb, 0x93, 0x8a, 0x30}
	binaryIDGlUniform2i                                      = binary.ID{0x9a, 0xd2, 0x5d, 0xe1, 0x6e, 0xbd, 0x4b, 0x3b, 0xab, 0x38, 0x0e, 0xe7, 0xc1, 0x1a, 0xd6, 0xff, 0x54, 0x3e, 0xc7, 0x17}
	binaryIDGlUniform2iv                                     = binary.ID{0xf9, 0xa4, 0xd9, 0x3e, 0xd7, 0x0e, 0xe3, 0x9a, 0x5e, 0x3d, 0x4a, 0xde, 0xad, 0x9b, 0x7c, 0x85, 0x11, 0x6a, 0x04, 0x1f}
	binaryIDGlUniform2ui                                     = binary.ID{0xfb, 0xd6, 0xeb, 0xff, 0x97, 0xcc, 0x50, 0x34, 0x18, 0x82, 0x2a, 0xba, 0x09, 0xfa, 0x80, 0xb7, 0x11, 0x35, 0x29, 0x2c}
	binaryIDGlUniform2uiv                                    = binary.ID{0x60, 0x66, 0x72, 0x5f, 0x51, 0x2b, 0x97, 0xeb, 0xe0, 0xd7, 0x28, 0xe3, 0xe6, 0xf3, 0xf1, 0x46, 0xd8, 0x14, 0xc3, 0x77}
	binaryIDGlUniform3f                                      = binary.ID{0x62, 0x49, 0x33, 0x98, 0xc8, 0x47, 0x02, 0x3b, 0x93, 0xd4, 0x48, 0x3b, 0x81, 0xfc, 0x72, 0xc7, 0x3c, 0x50, 0x2e, 0x12}
	binaryIDGlUniform3fv                                     = binary.ID{0xa4, 0x18, 0xf2, 0x40, 0xce, 0x31, 0x8f, 0xe9, 0xbb, 0x49, 0x24, 0x0a, 0x55, 0x1c, 0xf0, 0x00, 0xec, 0xcc, 0xe1, 0x72}
	binaryIDGlUniform3i                                      = binary.ID{0xf5, 0x43, 0x5e, 0x4d, 0x69, 0x85, 0xdc, 0x5c, 0xf9, 0xf3, 0x2e, 0x5d, 0xc3, 0x45, 0x3a, 0x32, 0x3e, 0xf1, 0x8c, 0x23}
	binaryIDGlUniform3iv                                     = binary.ID{0x33, 0xf7, 0x26, 0x18, 0xe9, 0xdd, 0x38, 0x7e, 0xff, 0xdd, 0xd0, 0x42, 0xce, 0x4d, 0x46, 0x97, 0x9c, 0x56, 0xb5, 0x1a}
	binaryIDGlUniform3ui                                     = binary.ID{0x95, 0x05, 0x9f, 0x1f, 0x11, 0x68, 0x6b, 0x8a, 0xe1, 0x0e, 0xe6, 0x8e, 0x97, 0xf9, 0x7a, 0x0e, 0xc3, 0xc1, 0xe6, 0x36}
	binaryIDGlUniform3uiv                                    = binary.ID{0xe2, 0xc4, 0xc9, 0xb8, 0x3b, 0xba, 0x43, 0xdb, 0xd9, 0xbf, 0xd8, 0x71, 0xd5, 0x51, 0xa4, 0x65, 0xd5, 0x06, 0x37, 0x3b}
	binaryIDGlUniform4f                                      = binary.ID{0xe2, 0x9e, 0xf8, 0x59, 0xaa, 0xc7, 0xb6, 0x64, 0xef, 0x62, 0xc7, 0xc2, 0x32, 0x62, 0x79, 0x66, 0xe5, 0xff, 0x4a, 0x7f}
	binaryIDGlUniform4fv                                     = binary.ID{0x7d, 0x55, 0xee, 0x1f, 0xbb, 0xb8, 0x48, 0xf6, 0x16, 0x69, 0xaf, 0x25, 0x98, 0xb1, 0xd5, 0xf4, 0x0b, 0x9f, 0x6e, 0xdc}
	binaryIDGlUniform4i                                      = binary.ID{0x85, 0xa5, 0x42, 0x63, 0x6d, 0x23, 0x58, 0x92, 0x5b, 0x26, 0x1b, 0xe3, 0x26, 0x82, 0x15, 0x47, 0x99, 0xa7, 0xfb, 0x18}
	binaryIDGlUniform4iv                                     = binary.ID{0x8b, 0x1c, 0xcc, 0xdc, 0x11, 0xcf, 0xc7, 0x8f, 0x7c, 0xf2, 0xbe, 0x8d, 0x4e, 0x45, 0xac, 0x59, 0x68, 0x14, 0x9d, 0x24}
	binaryIDGlUniform4ui                                     = binary.ID{0x59, 0x87, 0xa2, 0x7a, 0xba, 0x48, 0xae, 0x14, 0xa2, 0xbb, 0xc2, 0x70, 0xde, 0xcf, 0x1d, 0x25, 0x6e, 0xf7, 0xfe, 0xf9}
	binaryIDGlUniform4uiv                                    = binary.ID{0x00, 0xdf, 0x8e, 0xf7, 0x64, 0xf4, 0xcb, 0xa6, 0x7c, 0x52, 0x0a, 0x21, 0x34, 0x51, 0x87, 0x42, 0x7f, 0x7a, 0x44, 0x34}
	binaryIDGlUniformBlockBinding                            = binary.ID{0x3f, 0xee, 0xa1, 0x98, 0x3a, 0x2f, 0x8f, 0x61, 0x1a, 0xd3, 0x78, 0x2c, 0xc1, 0xe8, 0x29, 0xcb, 0xc1, 0xab, 0x69, 0x8f}
	binaryIDGlUniformHandleui64NV                            = binary.ID{0xf4, 0xb5, 0xbc, 0xe2, 0xc5, 0x0e, 0xda, 0x1a, 0x7a, 0xf7, 0x7d, 0x77, 0x4e, 0x19, 0x15, 0xed, 0xd9, 0xf0, 0x8a, 0xe2}
	binaryIDGlUniformHandleui64vNV                           = binary.ID{0xd2, 0x60, 0x5d, 0x9c, 0xa4, 0xb8, 0x60, 0xc4, 0x5a, 0x3e, 0x4e, 0x50, 0x48, 0x44, 0x77, 0x07, 0x5d, 0xda, 0x82, 0x84}
	binaryIDGlUniformMatrix2fv                               = binary.ID{0x27, 0x65, 0xd9, 0xa5, 0xce, 0x5f, 0xda, 0x93, 0xcd, 0x04, 0x03, 0x9a, 0x0a, 0x43, 0x14, 0x43, 0x68, 0xba, 0x64, 0x55}
	binaryIDGlUniformMatrix2x3fv                             = binary.ID{0x41, 0x68, 0xbc, 0x75, 0x28, 0xb2, 0x45, 0xfa, 0x8e, 0x7a, 0xa8, 0xdc, 0xc6, 0x36, 0xb8, 0xbb, 0x80, 0xa0, 0x9c, 0x7f}
	binaryIDGlUniformMatrix2x3fvNV                           = binary.ID{0xaf, 0x8b, 0x2e, 0x47, 0x33, 0x21, 0x37, 0x57, 0x13, 0x56, 0x41, 0x32, 0xa6, 0x58, 0x9a, 0xb9, 0xf9, 0xbf, 0x01, 0xe2}
	binaryIDGlUniformMatrix2x4fv                             = binary.ID{0xa1, 0x7d, 0xe6, 0x97, 0x24, 0x7d, 0xad, 0x90, 0x5a, 0x44, 0x54, 0xa9, 0x9b, 0x32, 0xeb, 0xe7, 0x97, 0xe7, 0x64, 0xca}
	binaryIDGlUniformMatrix2x4fvNV                           = binary.ID{0xee, 0x2a, 0x63, 0x13, 0xf3, 0x97, 0x7e, 0x7c, 0x88, 0xb5, 0x04, 0x98, 0x48, 0xe4, 0x7f, 0xff, 0x7d, 0x68, 0x8f, 0xa7}
	binaryIDGlUniformMatrix3fv                               = binary.ID{0x61, 0xdd, 0x5a, 0xb7, 0x6d, 0x45, 0x86, 0x02, 0x3f, 0xa5, 0x6e, 0x8e, 0xbc, 0x51, 0x0d, 0xa4, 0x6c, 0xcc, 0xde, 0x53}
	binaryIDGlUniformMatrix3x2fv                             = binary.ID{0x32, 0x43, 0x63, 0x2f, 0x06, 0xca, 0xa6, 0xd6, 0xe1, 0xb0, 0xd4, 0x04, 0x3e, 0x3a, 0xc0, 0x4b, 0xca, 0xbd, 0xf8, 0xbe}
	binaryIDGlUniformMatrix3x2fvNV                           = binary.ID{0x89, 0x17, 0x90, 0x3d, 0x24, 0xb9, 0x78, 0x1d, 0x26, 0x39, 0x7f, 0x95, 0x9f, 0x21, 0x14, 0xa3, 0x3f, 0xdb, 0x25, 0x93}
	binaryIDGlUniformMatrix3x4fv                             = binary.ID{0x0c, 0xf2, 0x89, 0x51, 0x97, 0x94, 0xb5, 0x30, 0xf1, 0x50, 0xc9, 0x7f, 0x67, 0xcd, 0x4c, 0x86, 0x79, 0x5a, 0xe3, 0xba}
	binaryIDGlUniformMatrix3x4fvNV                           = binary.ID{0x6f, 0x63, 0xf7, 0x17, 0x75, 0xe3, 0x3b, 0x6d, 0x27, 0xb9, 0x57, 0x55, 0xa3, 0xb6, 0x05, 0x06, 0x42, 0xfb, 0x7b, 0xdd}
	binaryIDGlUniformMatrix4fv                               = binary.ID{0xe6, 0x84, 0x67, 0xea, 0x90, 0x0e, 0x34, 0x23, 0xd8, 0x5b, 0xae, 0x3a, 0x65, 0xc3, 0x53, 0xf2, 0xab, 0x13, 0x17, 0x83}
	binaryIDGlUniformMatrix4x2fv                             = binary.ID{0x1d, 0xf0, 0xec, 0x91, 0xb0, 0x5d, 0xf3, 0x40, 0x77, 0xa8, 0x59, 0x7a, 0x3c, 0x28, 0xab, 0x0b, 0xea, 0x56, 0xbd, 0xbd}
	binaryIDGlUniformMatrix4x2fvNV                           = binary.ID{0xa9, 0xec, 0xae, 0xf7, 0x42, 0xb1, 0xa2, 0x10, 0x9d, 0xf6, 0x70, 0xc3, 0x26, 0xc1, 0x0f, 0x86, 0x04, 0x99, 0xa0, 0xf2}
	binaryIDGlUniformMatrix4x3fv                             = binary.ID{0xf3, 0x89, 0xf2, 0x23, 0xfa, 0x13, 0x32, 0x11, 0xef, 0xf9, 0x01, 0x60, 0x9c, 0x9c, 0xa7, 0xd2, 0x0b, 0xcd, 0xbd, 0x91}
	binaryIDGlUniformMatrix4x3fvNV                           = binary.ID{0x7b, 0x61, 0xa7, 0x20, 0x30, 0x0c, 0xd5, 0x36, 0x3d, 0x54, 0x2a, 0x3b, 0xda, 0x5d, 0x3f, 0xf3, 0xff, 0xfb, 0x51, 0xa1}
	binaryIDGlUnmapBuffer                                    = binary.ID{0xdf, 0x89, 0x91, 0x8a, 0x15, 0x4d, 0x24, 0x5c, 0x66, 0x31, 0x8a, 0x4d, 0x3d, 0x43, 0xd0, 0x6d, 0x2f, 0x5c, 0x23, 0x22}
	binaryIDGlUnmapBufferOES                                 = binary.ID{0xf4, 0xa9, 0x11, 0x34, 0x5a, 0x78, 0x2d, 0x49, 0x2e, 0x27, 0x11, 0x87, 0x80, 0x18, 0x84, 0x8c, 0x00, 0x80, 0xf9, 0x9d}
	binaryIDGlUseProgram                                     = binary.ID{0x4b, 0x8d, 0xa5, 0x92, 0x0f, 0xae, 0x78, 0xf9, 0xa4, 0xae, 0x29, 0x3c, 0xa1, 0x5b, 0x2c, 0xe4, 0xe2, 0xf6, 0x0b, 0x9b}
	binaryIDGlUseProgramStages                               = binary.ID{0xd2, 0x55, 0x91, 0x01, 0xda, 0xff, 0x26, 0xc1, 0x2e, 0x40, 0x4a, 0xad, 0xd6, 0xb8, 0xbf, 0x05, 0xc1, 0xa4, 0xb2, 0xd3}
	binaryIDGlUseProgramStagesEXT                            = binary.ID{0x88, 0xac, 0xc8, 0x7f, 0x82, 0x90, 0x8d, 0x2f, 0xfe, 0x5e, 0x59, 0x98, 0x41, 0xaa, 0x56, 0x44, 0xf3, 0xf8, 0x52, 0x09}
	binaryIDGlValidateProgram                                = binary.ID{0x51, 0xe9, 0x87, 0x35, 0x9c, 0x27, 0xef, 0x70, 0xbf, 0xce, 0x08, 0x9c, 0xe0, 0xa7, 0x47, 0xac, 0xab, 0xe5, 0xed, 0xd5}
	binaryIDGlValidateProgramPipeline                        = binary.ID{0xa0, 0x31, 0x09, 0xcf, 0xbe, 0xd2, 0xb0, 0xcf, 0x7b, 0x21, 0xef, 0x52, 0xfb, 0xd7, 0x5d, 0x41, 0x5c, 0x4a, 0x24, 0xf4}
	binaryIDGlValidateProgramPipelineEXT                     = binary.ID{0xe4, 0xd4, 0x9b, 0x55, 0x6c, 0x66, 0xe0, 0x50, 0xdf, 0xd4, 0x58, 0x03, 0x32, 0x1f, 0xa1, 0xec, 0x22, 0xe1, 0xba, 0xfb}
	binaryIDGlVertexAttrib1f                                 = binary.ID{0x82, 0xcf, 0xc1, 0x24, 0xa7, 0xe3, 0xc7, 0x4b, 0xe7, 0xb8, 0x76, 0x17, 0xdf, 0x30, 0xdf, 0x48, 0xeb, 0xf9, 0x2d, 0x5c}
	binaryIDGlVertexAttrib1fv                                = binary.ID{0x8b, 0xdd, 0x0b, 0x3d, 0xa7, 0x1b, 0x95, 0x9e, 0x79, 0x61, 0xd0, 0x3f, 0x78, 0xd9, 0x61, 0x07, 0xa3, 0x84, 0xd6, 0xde}
	binaryIDGlVertexAttrib2f                                 = binary.ID{0x27, 0xb5, 0x6d, 0x3d, 0x20, 0x96, 0xd0, 0x4f, 0x90, 0x2a, 0x20, 0x47, 0x48, 0xb4, 0x6e, 0x72, 0x6b, 0x47, 0x91, 0x0c}
	binaryIDGlVertexAttrib2fv                                = binary.ID{0x39, 0xc7, 0x55, 0xff, 0x91, 0x52, 0x4c, 0x62, 0x07, 0x60, 0x67, 0xb3, 0xe0, 0xf0, 0x5f, 0x2e, 0x84, 0xa1, 0xd9, 0x2f}
	binaryIDGlVertexAttrib3f                                 = binary.ID{0xe4, 0xa0, 0xe9, 0xc7, 0x73, 0x55, 0xfe, 0x7e, 0x5f, 0xca, 0x8e, 0xca, 0x10, 0x70, 0x13, 0x8d, 0x64, 0x5a, 0xa2, 0xcd}
	binaryIDGlVertexAttrib3fv                                = binary.ID{0x03, 0xd0, 0xa0, 0x95, 0x75, 0x66, 0x4b, 0x7d, 0x22, 0x05, 0xba, 0xf1, 0x05, 0x43, 0x63, 0xbd, 0x1e, 0x88, 0xf0, 0x2c}
	binaryIDGlVertexAttrib4f                                 = binary.ID{0xbd, 0xf7, 0x69, 0xbd, 0xce, 0x95, 0x29, 0x1c, 0xfd, 0x43, 0x9c, 0x65, 0xbf, 0x5c, 0xc7, 0x4c, 0x77, 0x3a, 0xb6, 0xfc}
	binaryIDGlVertexAttrib4fv                                = binary.ID{0x94, 0xea, 0xe9, 0xc2, 0xc0, 0x15, 0x67, 0xc8, 0xaf, 0xe0, 0x26, 0x64, 0x70, 0x2d, 0x93, 0x05, 0xfa, 0xde, 0xc4, 0xc9}
	binaryIDGlVertexAttribBinding                            = binary.ID{0x40, 0x5b, 0xc5, 0xdc, 0xeb, 0xe4, 0xdf, 0xa0, 0xc5, 0xad, 0xa8, 0x12, 0x98, 0x07, 0xce, 0xb9, 0x4c, 0x8c, 0x0f, 0xaf}
	binaryIDGlVertexAttribDivisor                            = binary.ID{0xf8, 0xfa, 0x5c, 0xb5, 0xb1, 0xac, 0x6e, 0xce, 0x66, 0xf1, 0xa8, 0xf0, 0x26, 0x91, 0xe8, 0xf0, 0x56, 0x3a, 0xeb, 0xf1}
	binaryIDGlVertexAttribDivisorANGLE                       = binary.ID{0x55, 0x7a, 0xbf, 0x43, 0xe7, 0xed, 0x50, 0x87, 0xf2, 0xc5, 0x62, 0x93, 0xe3, 0x38, 0xa9, 0x19, 0x90, 0xf2, 0x94, 0x00}
	binaryIDGlVertexAttribDivisorEXT                         = binary.ID{0x73, 0x06, 0x91, 0x32, 0x0b, 0x54, 0xb5, 0xee, 0x58, 0x9f, 0x8c, 0x7a, 0xc9, 0xee, 0x88, 0xdd, 0x16, 0x1f, 0xde, 0x4a}
	binaryIDGlVertexAttribDivisorNV                          = binary.ID{0x7f, 0xc1, 0x7f, 0x62, 0x8a, 0x1e, 0x58, 0xa3, 0x93, 0x74, 0xe2, 0x46, 0x6b, 0xe8, 0x0f, 0xaf, 0x57, 0x19, 0x43, 0x2c}
	binaryIDGlVertexAttribFormat                             = binary.ID{0xc8, 0xf9, 0xcf, 0xaa, 0x14, 0x6c, 0x4d, 0xe6, 0xdd, 0xf2, 0xdc, 0x49, 0xba, 0x33, 0x9a, 0xe6, 0x95, 0xb4, 0x0e, 0x62}
	binaryIDGlVertexAttribI4i                                = binary.ID{0x4f, 0x2e, 0xd9, 0x7a, 0xa9, 0x58, 0x21, 0x38, 0xdc, 0xd1, 0xbe, 0x2e, 0xbe, 0xbe, 0x56, 0x05, 0x1f, 0xec, 0xfc, 0x75}
	binaryIDGlVertexAttribI4iv                               = binary.ID{0x44, 0x96, 0xbb, 0xe2, 0xa2, 0x85, 0xb9, 0x2e, 0x7a, 0x6a, 0xb6, 0xdc, 0x19, 0x45, 0xb4, 0xf4, 0x0d, 0x75, 0xbb, 0xd6}
	binaryIDGlVertexAttribI4ui                               = binary.ID{0x5e, 0x6f, 0x34, 0x33, 0x1f, 0x46, 0x84, 0xb9, 0x1d, 0x7c, 0x00, 0xc8, 0xf1, 0xef, 0xa6, 0x2d, 0x98, 0x51, 0x3f, 0xd7}
	binaryIDGlVertexAttribI4uiv                              = binary.ID{0x9e, 0x75, 0x6b, 0x92, 0xb6, 0x5b, 0xb9, 0xb8, 0x7a, 0x3e, 0xc4, 0x90, 0x03, 0x7d, 0x31, 0xb2, 0x0a, 0x09, 0x17, 0xae}
	binaryIDGlVertexAttribIFormat                            = binary.ID{0x6f, 0x9a, 0xbc, 0xe0, 0x7f, 0x44, 0x96, 0xc3, 0xfa, 0xee, 0xc8, 0x98, 0xba, 0x8b, 0x44, 0xf3, 0x87, 0x97, 0x07, 0xb0}
	binaryIDGlVertexAttribIPointer                           = binary.ID{0x7f, 0x10, 0x3a, 0xc4, 0x1e, 0xab, 0x53, 0x48, 0x07, 0x47, 0x52, 0xe1, 0xf0, 0xa6, 0x7f, 0xcf, 0x11, 0xa1, 0xff, 0x2e}
	binaryIDGlVertexAttribPointer                            = binary.ID{0xa9, 0xf4, 0x7e, 0x3b, 0x7c, 0x9d, 0x74, 0x34, 0xf5, 0x0b, 0xad, 0xb3, 0xd8, 0x9b, 0x87, 0xf9, 0xef, 0xf5, 0x5f, 0x90}
	binaryIDGlVertexBindingDivisor                           = binary.ID{0x22, 0xb4, 0x64, 0x01, 0x30, 0xcc, 0x39, 0x6c, 0x72, 0x22, 0xc2, 0x5b, 0xc5, 0xfe, 0x55, 0xc8, 0xe4, 0x22, 0x62, 0x8f}
	binaryIDGlViewport                                       = binary.ID{0x03, 0xfa, 0x0b, 0x41, 0x52, 0x97, 0x87, 0x00, 0x14, 0xd1, 0xf0, 0xff, 0x04, 0x25, 0x0d, 0x5c, 0x62, 0xc5, 0x50, 0xd8}
	binaryIDGlViewportArrayvNV                               = binary.ID{0x53, 0x50, 0xaf, 0x8d, 0x81, 0x9f, 0xd8, 0xf0, 0xcd, 0xea, 0xaa, 0x5d, 0x76, 0x9f, 0x19, 0x16, 0x7c, 0xea, 0xd0, 0x0c}
	binaryIDGlViewportIndexedfNV                             = binary.ID{0x33, 0x4a, 0x6f, 0x26, 0x11, 0xde, 0x78, 0x98, 0x9c, 0x91, 0xa6, 0xd0, 0x3f, 0xab, 0xe9, 0xfa, 0x6d, 0xb8, 0x09, 0x8d}
	binaryIDGlViewportIndexedfvNV                            = binary.ID{0xae, 0x97, 0x4d, 0xcc, 0xb2, 0x72, 0xe4, 0xcd, 0xf7, 0x8d, 0x3d, 0x5f, 0x96, 0xc0, 0x6e, 0x86, 0x59, 0x1e, 0x48, 0x42}
	binaryIDGlWaitSync                                       = binary.ID{0xc8, 0xae, 0x34, 0x98, 0x55, 0xd2, 0x63, 0xd8, 0x1e, 0x95, 0xcc, 0xa2, 0xf7, 0xa1, 0x94, 0xd0, 0xec, 0x1b, 0x2c, 0xfa}
	binaryIDGlWaitSyncAPPLE                                  = binary.ID{0xa3, 0x89, 0x25, 0x81, 0xda, 0xcf, 0xae, 0x57, 0x8d, 0x5b, 0x9c, 0x3d, 0x46, 0x8b, 0xf0, 0xc0, 0xb1, 0xb1, 0x5b, 0x3a}
	binaryIDGlWeightPathsNV                                  = binary.ID{0x98, 0xff, 0x56, 0xe3, 0xe9, 0x76, 0xbd, 0xde, 0xc0, 0xb8, 0xfc, 0x07, 0xbf, 0x5a, 0x19, 0xb9, 0x49, 0xdb, 0x70, 0xa8}
	binaryIDGlXCreateContext                                 = binary.ID{0x69, 0xd6, 0x87, 0x67, 0x9c, 0x50, 0x4f, 0xe6, 0x49, 0x6b, 0x1a, 0x51, 0x2f, 0xd7, 0x22, 0x72, 0x8e, 0x01, 0xda, 0x6e}
	binaryIDGlXCreateNewContext                              = binary.ID{0x84, 0x7e, 0x5e, 0x97, 0x8c, 0x27, 0x99, 0x7b, 0x5e, 0xd5, 0x5f, 0xc8, 0xd5, 0xc1, 0x5e, 0x0c, 0x90, 0x64, 0xf7, 0x43}
	binaryIDGlXMakeContextCurrent                            = binary.ID{0x4e, 0x6d, 0x3c, 0x63, 0x7f, 0x49, 0x79, 0x4e, 0x3d, 0xd0, 0xd9, 0x0c, 0xcf, 0x72, 0x94, 0x3f, 0x6b, 0xfd, 0x77, 0xfd}
	binaryIDGlXMakeCurrent                                   = binary.ID{0xa6, 0xaf, 0xc1, 0x6f, 0x1c, 0x9b, 0xdb, 0x26, 0x13, 0x0b, 0x75, 0xa3, 0x14, 0xb9, 0x1b, 0x58, 0x37, 0xa6, 0x23, 0xc8}
	binaryIDIntᵖ                                             = binary.ID{0x2b, 0x06, 0x77, 0x85, 0xff, 0x02, 0x77, 0xf8, 0xbc, 0x87, 0x72, 0xeb, 0xf8, 0x53, 0x2e, 0x65, 0xd2, 0x8f, 0x69, 0x27}
	binaryIDGlXQueryDrawable                                 = binary.ID{0x17, 0xd3, 0x19, 0xa4, 0xba, 0x07, 0x32, 0xb5, 0xc2, 0x76, 0xae, 0xde, 0xfe, 0x31, 0x95, 0x07, 0x79, 0xdb, 0xd0, 0xd6}
	binaryIDGlXSwapBuffers                                   = binary.ID{0x6f, 0x6a, 0xec, 0x59, 0x43, 0x85, 0x4a, 0xf5, 0x61, 0xc7, 0xb1, 0x28, 0x6c, 0x34, 0xa5, 0xb8, 0xbd, 0x25, 0x12, 0xc2}
	binaryIDHDC                                              = binary.ID{0x9c, 0x52, 0x64, 0x9a, 0xd1, 0x46, 0x9a, 0x9a, 0xa1, 0x08, 0x15, 0x09, 0x48, 0x2d, 0xd9, 0x49, 0xf9, 0x70, 0x31, 0xd1}
	binaryIDHGLRC                                            = binary.ID{0x85, 0x70, 0xb4, 0x61, 0xd4, 0x4f, 0xbf, 0xd6, 0xc1, 0x35, 0x12, 0x3e, 0xfd, 0xca, 0x6b, 0xa8, 0x72, 0x03, 0x3e, 0xc1}
	binaryIDIntˢ                                             = binary.ID{0x81, 0xe7, 0x7a, 0x15, 0x73, 0x0c, 0x03, 0xb6, 0x9f, 0x6c, 0xec, 0x7b, 0x08, 0xf2, 0xc1, 0x20, 0x9f, 0xcd, 0x72, 0x5a}
	binaryIDVec2f                                            = binary.ID{0xcd, 0xd2, 0x53, 0x90, 0x81, 0x0b, 0x84, 0x25, 0x94, 0x09, 0xe0, 0x0a, 0xb8, 0x5f, 0xac, 0x9d, 0x98, 0x54, 0x5f, 0x03}
	binaryIDMat2f                                            = binary.ID{0xb3, 0xca, 0x65, 0x73, 0x09, 0x4d, 0x46, 0x20, 0x2e, 0x2a, 0x3d, 0x75, 0x6b, 0x7b, 0xc3, 0xaf, 0x18, 0x79, 0xfe, 0xcb}
	binaryIDMat2fˢ                                           = binary.ID{0xfd, 0x99, 0x6e, 0x41, 0x72, 0xbc, 0xf9, 0x44, 0xfb, 0x0c, 0x17, 0x18, 0x6e, 0x78, 0x41, 0x4a, 0xe4, 0xf9, 0x01, 0xe9}
	binaryIDMat2fᵖ                                           = binary.ID{0xaa, 0x78, 0xb0, 0xc3, 0xec, 0xe3, 0xcf, 0x0c, 0x6e, 0xd0, 0xaf, 0xf6, 0x7b, 0x56, 0xa1, 0x18, 0x16, 0x3e, 0xbe, 0x78}
	binaryIDVec3f                                            = binary.ID{0xa4, 0x58, 0x33, 0xc3, 0xfe, 0xce, 0x96, 0x95, 0x47, 0x66, 0x2e, 0xb4, 0x02, 0xaf, 0x60, 0x31, 0xe9, 0x50, 0x20, 0x5f}
	binaryIDMat3f                                            = binary.ID{0x47, 0x2d, 0x69, 0x38, 0x46, 0x76, 0x50, 0xf5, 0x0b, 0x0f, 0x50, 0x2f, 0x41, 0xfb, 0x03, 0xa7, 0xd3, 0xd7, 0x38, 0x51}
	binaryIDMat3fˢ                                           = binary.ID{0x0e, 0x3f, 0xf2, 0x97, 0xf4, 0x3f, 0x26, 0xb0, 0x40, 0x83, 0x20, 0xad, 0x0b, 0xa3, 0xce, 0xf7, 0x9b, 0xd8, 0x51, 0x10}
	binaryIDMat3fᵖ                                           = binary.ID{0xd1, 0x68, 0x7a, 0xc6, 0x58, 0xc5, 0x77, 0x79, 0x03, 0x73, 0x9e, 0x3b, 0x4c, 0xf3, 0x45, 0x83, 0xe6, 0xac, 0x4d, 0xe6}
	binaryIDVec4f                                            = binary.ID{0xd5, 0x87, 0xc0, 0x3a, 0xd5, 0x96, 0x18, 0x54, 0x87, 0x09, 0x02, 0x96, 0xf3, 0xac, 0x20, 0x2a, 0x32, 0x06, 0x91, 0x5f}
	binaryIDMat4f                                            = binary.ID{0xb7, 0xf0, 0xe0, 0x8d, 0x26, 0xbd, 0x22, 0x55, 0x90, 0xcd, 0x63, 0x7d, 0x27, 0x59, 0xbd, 0xa2, 0xa3, 0x72, 0xc2, 0x95}
	binaryIDMat4fˢ                                           = binary.ID{0xd0, 0xcc, 0x8f, 0x5c, 0xd1, 0x03, 0xe7, 0x55, 0x69, 0x29, 0xad, 0x0e, 0x5c, 0xe3, 0xd2, 0x1f, 0xb7, 0xa9, 0xf1, 0xa1}
	binaryIDMat4fᵖ                                           = binary.ID{0x72, 0x0c, 0xc7, 0x00, 0x98, 0x6d, 0xc2, 0x9f, 0xab, 0xc1, 0xba, 0x25, 0x74, 0x6b, 0xc6, 0x34, 0x95, 0x4a, 0x43, 0x16}
	binaryIDPipelineIdˢ                                      = binary.ID{0x53, 0xe1, 0x5d, 0x1e, 0xdc, 0xbb, 0xc7, 0x46, 0x78, 0x24, 0xf3, 0xe1, 0x67, 0xaf, 0x95, 0x57, 0xfa, 0x65, 0xc2, 0xfb}
	binaryIDProgramIdˢ                                       = binary.ID{0x52, 0xfe, 0x85, 0xe9, 0xab, 0x13, 0x71, 0x7b, 0x28, 0x75, 0xd3, 0x54, 0x06, 0x68, 0x29, 0x22, 0xb4, 0x3b, 0x8a, 0xb2}
	binaryIDQueryIdˢ                                         = binary.ID{0x31, 0x42, 0xbd, 0xc9, 0x65, 0x42, 0xa6, 0x82, 0xd0, 0xba, 0x8e, 0x4f, 0x11, 0x84, 0xe4, 0xf5, 0x7a, 0xad, 0xa8, 0x88}
	binaryIDRenderbufferIdˢ                                  = binary.ID{0x8a, 0x81, 0xb2, 0x12, 0x5d, 0xf9, 0xa4, 0x6a, 0x07, 0x61, 0xd1, 0x2e, 0xff, 0x46, 0x04, 0x32, 0xf9, 0x38, 0xe5, 0xed}
	binaryIDReplayBindRenderer                               = binary.ID{0xdb, 0xb2, 0x76, 0x5b, 0xa5, 0x3d, 0xb0, 0xef, 0x04, 0x2a, 0x03, 0xf1, 0x57, 0x07, 0x5a, 0x92, 0x20, 0xa9, 0x0a, 0x8a}
	binaryIDReplayCreateRenderer                             = binary.ID{0xd5, 0x5d, 0xca, 0x28, 0xdc, 0x88, 0xac, 0x79, 0x3a, 0x31, 0xd4, 0xe3, 0x68, 0x68, 0xb9, 0x7a, 0xac, 0x48, 0x7e, 0x52}
	binaryIDS64ˢ                                             = binary.ID{0xf2, 0x00, 0xfb, 0x5a, 0xa6, 0x5d, 0x3a, 0xcb, 0x0c, 0x2e, 0x2d, 0xa5, 0x81, 0xbb, 0x08, 0x09, 0x13, 0x3a, 0xae, 0xb5}
	binaryIDSamplerIdˢ                                       = binary.ID{0x63, 0xc3, 0x53, 0xf2, 0xfe, 0x19, 0x8b, 0xac, 0x13, 0x63, 0xf8, 0x9f, 0x65, 0x63, 0xe5, 0x4a, 0xb4, 0x12, 0x7c, 0x77}
	binaryIDShaderIdˢ                                        = binary.ID{0x45, 0x01, 0xd6, 0x03, 0x00, 0x91, 0x9a, 0x24, 0xe3, 0x7e, 0x26, 0x7e, 0x7d, 0xda, 0xf1, 0x06, 0x42, 0x59, 0x3e, 0x03}
	binaryIDStartTimer                                       = binary.ID{0x23, 0x7b, 0x88, 0x65, 0x96, 0xf3, 0x0d, 0x5d, 0x50, 0x56, 0xad, 0x18, 0xc8, 0x0a, 0xe8, 0x57, 0xa0, 0x21, 0x1c, 0x9b}
	binaryIDState                                            = binary.ID{0x9a, 0x1a, 0xdb, 0xe0, 0xa0, 0x77, 0x65, 0xd3, 0x62, 0x31, 0x3f, 0xcb, 0x81, 0xbd, 0x45, 0xc3, 0x24, 0xe7, 0x94, 0x2d}
	binaryIDStopTimer                                        = binary.ID{0xe8, 0x9f, 0x7c, 0xb1, 0xa4, 0xf8, 0x37, 0x81, 0x6b, 0x01, 0x71, 0x0e, 0xbc, 0xf2, 0x92, 0xd2, 0x39, 0x2e, 0xca, 0x5f}
	binaryIDSwitchThread                                     = binary.ID{0x82, 0x4e, 0xdc, 0x09, 0x39, 0x98, 0x76, 0xf4, 0x8a, 0x87, 0x2d, 0x58, 0x44, 0x40, 0x0f, 0x33, 0x33, 0x08, 0xb4, 0x8f}
	binaryIDTextureIdˢ                                       = binary.ID{0x4a, 0xe8, 0xe0, 0x14, 0x09, 0x7c, 0x25, 0x10, 0x88, 0xb0, 0xf9, 0x39, 0x88, 0xd0, 0x7d, 0x81, 0xc6, 0xb6, 0xed, 0x2f}
	binaryIDTransformFeedbackIdˢ                             = binary.ID{0xa9, 0x90, 0x44, 0x17, 0x4b, 0x82, 0x5f, 0xea, 0x8c, 0xd0, 0x7b, 0xbf, 0x88, 0x9b, 0x57, 0x07, 0x80, 0x09, 0x68, 0x37}
	binaryIDU16ˢ                                             = binary.ID{0xab, 0xc7, 0xa4, 0xfa, 0x83, 0x18, 0xe5, 0xa4, 0x77, 0xd6, 0xe0, 0x39, 0x46, 0xe4, 0x10, 0x4a, 0x48, 0x9d, 0xb0, 0xa7}
	binaryIDU16ᵖ                                             = binary.ID{0xba, 0xe7, 0x20, 0x23, 0x9a, 0x87, 0x4c, 0x4a, 0x81, 0x51, 0x1e, 0x87, 0xbe, 0xbf, 0xb5, 0xfe, 0x6d, 0xd4, 0x36, 0xdc}
	binaryIDU32ˢ                                             = binary.ID{0x7e, 0xa9, 0x64, 0x54, 0xe8, 0x49, 0x13, 0xf6, 0xf7, 0xcc, 0xcf, 0x79, 0x8e, 0xe9, 0x76, 0x73, 0xe6, 0x3a, 0x78, 0x88}
	binaryIDU32ᵖ                                             = binary.ID{0x16, 0xd1, 0x24, 0xcd, 0xeb, 0x2b, 0xe2, 0x05, 0xb4, 0x18, 0xea, 0xa5, 0x29, 0x58, 0x6e, 0x08, 0xd4, 0x8d, 0xdf, 0xaf}
	binaryIDU64ˢ                                             = binary.ID{0xe1, 0xd5, 0x02, 0xad, 0x4c, 0xbb, 0x1a, 0x36, 0xc7, 0xc8, 0x9b, 0x42, 0xfd, 0x46, 0xd0, 0xae, 0xd0, 0xa6, 0xbf, 0x6c}
	binaryIDU8ᵖ                                              = binary.ID{0xc9, 0x85, 0x15, 0x54, 0xd3, 0x40, 0x31, 0x19, 0x7a, 0xab, 0xf9, 0x64, 0x72, 0x38, 0x96, 0xa9, 0x85, 0xc3, 0xbb, 0x4d}
	binaryIDVec2fː2ᵃ                                         = binary.ID{0xf3, 0xfe, 0xa2, 0xa3, 0xb6, 0xdd, 0xd4, 0x15, 0x8c, 0x00, 0x2c, 0x4d, 0x78, 0x65, 0x14, 0x70, 0xe7, 0xcb, 0x7b, 0xe7}
	binaryIDVec2fˢ                                           = binary.ID{0x79, 0x71, 0xb9, 0xc2, 0x40, 0xfa, 0x23, 0xa9, 0x13, 0xc3, 0x59, 0x96, 0xcb, 0x6b, 0x81, 0xed, 0x4d, 0x1f, 0x31, 0x65}
	binaryIDVec2fᵖ                                           = binary.ID{0x55, 0xdc, 0xba, 0xe1, 0x45, 0x8e, 0x4f, 0xd9, 0x9f, 0x20, 0x5c, 0x36, 0x6e, 0x3a, 0xf9, 0x08, 0xa7, 0xd5, 0xbb, 0xff}
	binaryIDVec2i                                            = binary.ID{0x03, 0x78, 0x45, 0xfb, 0x2c, 0xf0, 0xd5, 0x8f, 0xd4, 0x78, 0xe6, 0x63, 0x81, 0x85, 0xe3, 0x06, 0x0c, 0x49, 0xd7, 0xba}
	binaryIDVec2iˢ                                           = binary.ID{0x6b, 0x83, 0xed, 0xc6, 0xad, 0xba, 0x33, 0x3e, 0xcd, 0x20, 0x1a, 0x3a, 0x70, 0x29, 0xa0, 0xc1, 0x65, 0xa0, 0x53, 0x5e}
	binaryIDVec2iᵖ                                           = binary.ID{0xaa, 0xd3, 0xa9, 0x60, 0x80, 0x64, 0x1c, 0xa9, 0xef, 0xdc, 0xe5, 0x54, 0x9e, 0xaa, 0x32, 0xf4, 0xc3, 0xf4, 0xb3, 0x15}
	binaryIDVec3fː3ᵃ                                         = binary.ID{0x13, 0xcd, 0x31, 0x33, 0xcd, 0xd2, 0xb7, 0xe2, 0xaa, 0xc1, 0xb9, 0x3d, 0xbb, 0x10, 0x88, 0x95, 0x1b, 0xcf, 0xd1, 0xde}
	binaryIDVec3fˢ                                           = binary.ID{0xba, 0xc9, 0xa5, 0x3c, 0xaa, 0x62, 0xc5, 0x18, 0x36, 0xc6, 0x3c, 0xaa, 0x5c, 0x15, 0xe9, 0x37, 0x5d, 0x11, 0xf4, 0xa1}
	binaryIDVec3fᵖ                                           = binary.ID{0xed, 0xc9, 0xbf, 0x84, 0x9c, 0xa4, 0x36, 0xf4, 0x8f, 0xaa, 0xc3, 0x7c, 0xb8, 0xfe, 0x6a, 0x3e, 0x9c, 0xc6, 0xd4, 0x87}
	binaryIDVec3i                                            = binary.ID{0xa2, 0x39, 0xe9, 0x4f, 0xe6, 0xf0, 0x02, 0x02, 0x97, 0x4b, 0x86, 0x0e, 0x33, 0xc4, 0xe8, 0x90, 0x49, 0x20, 0xdb, 0xb1}
	binaryIDVec3iˢ                                           = binary.ID{0x1a, 0x46, 0x23, 0xaf, 0x7e, 0x76, 0xc7, 0x5b, 0xca, 0xbd, 0x76, 0xaa, 0xaf, 0xb3, 0xdf, 0x90, 0xc7, 0xe5, 0xa0, 0x5f}
	binaryIDVec3iᵖ                                           = binary.ID{0x07, 0x78, 0x89, 0x2c, 0xfc, 0x6c, 0x17, 0xef, 0x84, 0xd5, 0x65, 0xbb, 0xc1, 0x25, 0x5c, 0xe3, 0xf8, 0xc6, 0x9c, 0x39}
	binaryIDVec4fː4ᵃ                                         = binary.ID{0x5b, 0x6d, 0xf1, 0x71, 0x8d, 0x7c, 0xc1, 0x20, 0x2b, 0x99, 0xb2, 0x24, 0xce, 0xb1, 0xf6, 0x8a, 0x90, 0xd9, 0xeb, 0x6c}
	binaryIDVec4fˢ                                           = binary.ID{0x9e, 0xbf, 0xba, 0xe1, 0x7e, 0xae, 0xbc, 0x30, 0x0c, 0x1b, 0xdf, 0xe9, 0x03, 0x12, 0x2d, 0xa3, 0x28, 0x55, 0xc6, 0x4b}
	binaryIDVec4fᵖ                                           = binary.ID{0xe4, 0x2d, 0x98, 0xc0, 0x13, 0x9e, 0xf8, 0xb2, 0xcc, 0x7e, 0xd1, 0x80, 0x7f, 0xa4, 0x1b, 0xf5, 0xb8, 0x58, 0x01, 0x73}
	binaryIDVec4i                                            = binary.ID{0x4d, 0x79, 0xb8, 0xa5, 0x90, 0x3f, 0x4f, 0x88, 0x9e, 0x1e, 0xbd, 0x93, 0x18, 0x75, 0x54, 0x2b, 0xb4, 0x02, 0x4a, 0x1f}
	binaryIDVec4iˢ                                           = binary.ID{0xee, 0x88, 0xf0, 0x68, 0xd6, 0xb7, 0xfa, 0xda, 0xb5, 0x1a, 0x68, 0x05, 0x6d, 0xbb, 0x69, 0x97, 0x08, 0x4f, 0x37, 0xe3}
	binaryIDVec4iᵖ                                           = binary.ID{0xe4, 0x08, 0x77, 0x3a, 0xc3, 0xb7, 0x95, 0x08, 0xef, 0xd4, 0xa3, 0xdb, 0x01, 0x8e, 0x39, 0x60, 0x08, 0xdf, 0xbb, 0x2a}
	binaryIDVertexArrayIdˢ                                   = binary.ID{0x33, 0x17, 0x79, 0xfd, 0x5c, 0x69, 0x07, 0xce, 0x86, 0x55, 0xd5, 0x6f, 0xde, 0x1e, 0xc6, 0xee, 0x52, 0x0a, 0xd8, 0x01}
	binaryIDVoidˢ                                            = binary.ID{0x8e, 0x07, 0x40, 0xb5, 0x18, 0x86, 0xc9, 0x8b, 0x33, 0xd0, 0x40, 0xab, 0x75, 0xb9, 0xef, 0x2f, 0x74, 0x66, 0x0a, 0x26}
	binaryIDVoidᵖˢ                                           = binary.ID{0x36, 0x6e, 0x56, 0x4d, 0x86, 0x80, 0xe4, 0xfc, 0x29, 0xe0, 0xf7, 0x48, 0x32, 0x6d, 0x23, 0xc4, 0xfe, 0x59, 0xeb, 0xd8}
	binaryIDVoidᶜᵖˢ                                          = binary.ID{0xe5, 0x93, 0x38, 0x0b, 0xa0, 0xd5, 0x27, 0xb0, 0x3a, 0x88, 0x5e, 0x97, 0x14, 0xbf, 0x81, 0x58, 0x0a, 0x33, 0x12, 0xa6}
	binaryIDVoidᶜᵖᵖ                                          = binary.ID{0x55, 0xdc, 0x47, 0x05, 0x4a, 0x87, 0x03, 0x48, 0x78, 0x44, 0x57, 0x64, 0x3f, 0x6d, 0x74, 0xbd, 0xad, 0x01, 0x30, 0x6b}
	binaryIDWglCreateContext                                 = binary.ID{0x8e, 0xe0, 0x9b, 0x8b, 0x3d, 0x3c, 0xc7, 0x22, 0x61, 0xb4, 0xee, 0xa9, 0x75, 0x75, 0xd6, 0x53, 0x0d, 0x31, 0x15, 0xcc}
	binaryIDWglCreateContextAttribsARB                       = binary.ID{0x28, 0x15, 0x85, 0xa3, 0xab, 0x16, 0x84, 0xed, 0xe0, 0xe6, 0xec, 0x92, 0xe8, 0x14, 0x8e, 0xbe, 0x5f, 0x32, 0x72, 0x42}
	binaryIDWglMakeCurrent                                   = binary.ID{0x86, 0xd3, 0x02, 0xb5, 0xf6, 0x1b, 0x7f, 0x3e, 0xb1, 0x23, 0x36, 0x2b, 0x9d, 0xa2, 0x13, 0xa6, 0xf6, 0xbc, 0xb3, 0x8a}
	binaryIDWglSwapBuffers                                   = binary.ID{0xa1, 0x23, 0xcd, 0xfc, 0xb1, 0x9b, 0xcf, 0x24, 0x77, 0xab, 0x3b, 0xb0, 0x75, 0x58, 0x9b, 0x35, 0x54, 0x11, 0x3f, 0xc8}
	binaryIDgenerate_types                                   = binary.ID{0x66, 0x3f, 0x56, 0xa1, 0xab, 0x3d, 0x6a, 0x7f, 0x2c, 0xf4, 0x25, 0xf5, 0x2c, 0xc2, 0x7f, 0x7f, 0x56, 0x5a, 0x44, 0x05}
)

type binaryClassArchitecture struct{}

func (*Architecture) Class() binary.Class {
	return (*binaryClassArchitecture)(nil)
}
func doEncodeArchitecture(e binary.Encoder, o *Architecture) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.PointerAlignment); err != nil {
		return err
	}
	if err := e.Uint32(o.PointerSize); err != nil {
		return err
	}
	if err := e.Uint32(o.IntegerSize); err != nil {
		return err
	}
	if err := e.Bool(o.LittleEndian); err != nil {
		return err
	}
	return nil
}
func doDecodeArchitecture(d binary.Decoder, o *Architecture) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PointerAlignment = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PointerSize = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.IntegerSize = uint32(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.LittleEndian = bool(obj)
	}
	return nil
}
func doSkipArchitecture(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassArchitecture) ID() binary.ID      { return binaryIDArchitecture }
func (*binaryClassArchitecture) New() binary.Object { return &Architecture{} }
func (*binaryClassArchitecture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeArchitecture(e, obj.(*Architecture))
}
func (*binaryClassArchitecture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Architecture{}
	return obj, doDecodeArchitecture(d, obj)
}
func (*binaryClassArchitecture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeArchitecture(d, obj.(*Architecture))
}
func (*binaryClassArchitecture) Skip(d binary.Decoder) error { return doSkipArchitecture(d) }
func (*binaryClassArchitecture) Schema() *schema.Class       { return schemaArchitecture }

var schemaArchitecture = &schema.Class{
	TypeID:  binaryIDArchitecture,
	Package: "gles",
	Name:    "Architecture",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "PointerAlignment", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "PointerSize", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "IntegerSize", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "LittleEndian", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassBackbufferInfo struct{}

func (*BackbufferInfo) Class() binary.Class {
	return (*binaryClassBackbufferInfo)(nil)
}
func doEncodeBackbufferInfo(e binary.Encoder, o *BackbufferInfo) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ColorFmt)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DepthFmt)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.StencilFmt)); err != nil {
		return err
	}
	if err := e.Bool(o.ResetViewportScissor); err != nil {
		return err
	}
	if err := e.Bool(o.PreserveBuffersOnSwap); err != nil {
		return err
	}
	return nil
}
func doDecodeBackbufferInfo(d binary.Decoder, o *BackbufferInfo) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ColorFmt = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DepthFmt = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.StencilFmt = GLenum(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.ResetViewportScissor = bool(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.PreserveBuffersOnSwap = bool(obj)
	}
	return nil
}
func doSkipBackbufferInfo(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBackbufferInfo) ID() binary.ID      { return binaryIDBackbufferInfo }
func (*binaryClassBackbufferInfo) New() binary.Object { return &BackbufferInfo{} }
func (*binaryClassBackbufferInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBackbufferInfo(e, obj.(*BackbufferInfo))
}
func (*binaryClassBackbufferInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BackbufferInfo{}
	return obj, doDecodeBackbufferInfo(d, obj)
}
func (*binaryClassBackbufferInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBackbufferInfo(d, obj.(*BackbufferInfo))
}
func (*binaryClassBackbufferInfo) Skip(d binary.Decoder) error { return doSkipBackbufferInfo(d) }
func (*binaryClassBackbufferInfo) Schema() *schema.Class       { return schemaBackbufferInfo }

var schemaBackbufferInfo = &schema.Class{
	TypeID:  binaryIDBackbufferInfo,
	Package: "gles",
	Name:    "BackbufferInfo",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "ColorFmt", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DepthFmt", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "StencilFmt", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ResetViewportScissor", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "PreserveBuffersOnSwap", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassColor struct{}

func (*Color) Class() binary.Class {
	return (*binaryClassColor)(nil)
}
func doEncodeColor(e binary.Encoder, o *Color) error {
	if err := e.Float32(float32(o.Red)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Green)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Blue)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Alpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeColor(d binary.Decoder, o *Color) error {
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Red = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Green = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Blue = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Alpha = GLfloat(obj)
	}
	return nil
}
func doSkipColor(d binary.Decoder) error {
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassColor) ID() binary.ID      { return binaryIDColor }
func (*binaryClassColor) New() binary.Object { return &Color{} }
func (*binaryClassColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeColor(e, obj.(*Color))
}
func (*binaryClassColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Color{}
	return obj, doDecodeColor(d, obj)
}
func (*binaryClassColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeColor(d, obj.(*Color))
}
func (*binaryClassColor) Skip(d binary.Decoder) error { return doSkipColor(d) }
func (*binaryClassColor) Schema() *schema.Class       { return schemaColor }

var schemaColor = &schema.Class{
	TypeID:  binaryIDColor,
	Package: "gles",
	Name:    "Color",
	Fields: []schema.Field{
		{Declared: "Red", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Green", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Blue", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Alpha", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassBlendState struct{}

func (*BlendState) Class() binary.Class {
	return (*binaryClassBlendState)(nil)
}
func doEncodeBlendState(e binary.Encoder, o *BlendState) error {
	if err := e.Uint32(uint32(o.SrcRgbBlendFactor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcAlphaBlendFactor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstRgbBlendFactor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstAlphaBlendFactor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BlendEquationRgb)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BlendEquationAlpha)); err != nil {
		return err
	}
	if err := e.Value(&o.BlendColor); err != nil {
		return err
	}
	return nil
}
func doDecodeBlendState(d binary.Decoder, o *BlendState) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcRgbBlendFactor = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcAlphaBlendFactor = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstRgbBlendFactor = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstAlphaBlendFactor = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BlendEquationRgb = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BlendEquationAlpha = GLenum(obj)
	}
	if err := d.Value(&o.BlendColor); err != nil {
		return err
	}
	return nil
}
func doSkipBlendState(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Color)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBlendState) ID() binary.ID      { return binaryIDBlendState }
func (*binaryClassBlendState) New() binary.Object { return &BlendState{} }
func (*binaryClassBlendState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBlendState(e, obj.(*BlendState))
}
func (*binaryClassBlendState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BlendState{}
	return obj, doDecodeBlendState(d, obj)
}
func (*binaryClassBlendState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBlendState(d, obj.(*BlendState))
}
func (*binaryClassBlendState) Skip(d binary.Decoder) error { return doSkipBlendState(d) }
func (*binaryClassBlendState) Schema() *schema.Class       { return schemaBlendState }

var schemaBlendState = &schema.Class{
	TypeID:  binaryIDBlendState,
	Package: "gles",
	Name:    "BlendState",
	Fields: []schema.Field{
		{Declared: "SrcRgbBlendFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcAlphaBlendFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstRgbBlendFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstAlphaBlendFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BlendEquationRgb", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BlendEquationAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BlendColor", Type: &schema.Struct{Name: "Color", ID: (*Color)(nil).Class().ID()}},
	},
}

type binaryClassSliceInfo struct{}

func (*SliceInfo) Class() binary.Class {
	return (*binaryClassSliceInfo)(nil)
}
func doEncodeSliceInfo(e binary.Encoder, o *SliceInfo) error {
	if err := e.Value(&o.Root); err != nil {
		return err
	}
	if err := e.Uint64(o.Base); err != nil {
		return err
	}
	if err := e.Uint64(o.Count); err != nil {
		return err
	}
	return nil
}
func doDecodeSliceInfo(d binary.Decoder, o *SliceInfo) error {
	if err := d.Value(&o.Root); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Base = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Count = uint64(obj)
	}
	return nil
}
func doSkipSliceInfo(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSliceInfo) ID() binary.ID      { return binaryIDSliceInfo }
func (*binaryClassSliceInfo) New() binary.Object { return &SliceInfo{} }
func (*binaryClassSliceInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSliceInfo(e, obj.(*SliceInfo))
}
func (*binaryClassSliceInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SliceInfo{}
	return obj, doDecodeSliceInfo(d, obj)
}
func (*binaryClassSliceInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSliceInfo(d, obj.(*SliceInfo))
}
func (*binaryClassSliceInfo) Skip(d binary.Decoder) error { return doSkipSliceInfo(d) }
func (*binaryClassSliceInfo) Schema() *schema.Class       { return schemaSliceInfo }

var schemaSliceInfo = &schema.Class{
	TypeID:  binaryIDSliceInfo,
	Package: "gles",
	Name:    "SliceInfo",
	Fields: []schema.Field{
		{Declared: "Root", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
		{Declared: "Base", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassU8ˢ struct{}

func (*U8ˢ) Class() binary.Class {
	return (*binaryClassU8ˢ)(nil)
}
func doEncodeU8ˢ(e binary.Encoder, o *U8ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU8ˢ(d binary.Decoder, o *U8ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU8ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU8ˢ) ID() binary.ID      { return binaryIDU8ˢ }
func (*binaryClassU8ˢ) New() binary.Object { return &U8ˢ{} }
func (*binaryClassU8ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU8ˢ(e, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U8ˢ{}
	return obj, doDecodeU8ˢ(d, obj)
}
func (*binaryClassU8ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU8ˢ(d, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Skip(d binary.Decoder) error { return doSkipU8ˢ(d) }
func (*binaryClassU8ˢ) Schema() *schema.Class       { return schemaU8ˢ }

var schemaU8ˢ = &schema.Class{
	TypeID:  binaryIDU8ˢ,
	Package: "gles",
	Name:    "U8ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassBuffer struct{}

func (*Buffer) Class() binary.Class {
	return (*binaryClassBuffer)(nil)
}
func doEncodeBuffer(e binary.Encoder, o *Buffer) error {
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Usage)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MappingAccess)); err != nil {
		return err
	}
	if err := e.Int32(o.MappingOffset); err != nil {
		return err
	}
	if err := e.Value(&o.MappingData); err != nil {
		return err
	}
	return nil
}
func doDecodeBuffer(d binary.Decoder, o *Buffer) error {
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Usage = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MappingAccess = GLbitfield(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MappingOffset = int32(obj)
	}
	if err := d.Value(&o.MappingData); err != nil {
		return err
	}
	return nil
}
func doSkipBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBuffer) ID() binary.ID      { return binaryIDBuffer }
func (*binaryClassBuffer) New() binary.Object { return &Buffer{} }
func (*binaryClassBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBuffer(e, obj.(*Buffer))
}
func (*binaryClassBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Buffer{}
	return obj, doDecodeBuffer(d, obj)
}
func (*binaryClassBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBuffer(d, obj.(*Buffer))
}
func (*binaryClassBuffer) Skip(d binary.Decoder) error { return doSkipBuffer(d) }
func (*binaryClassBuffer) Schema() *schema.Class       { return schemaBuffer }

var schemaBuffer = &schema.Class{
	TypeID:  binaryIDBuffer,
	Package: "gles",
	Name:    "Buffer",
	Fields: []schema.Field{
		{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Usage", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "MappingAccess", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "MappingOffset", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
		{Declared: "MappingData", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
	},
}

type binaryClassBufferDataPointer struct{}

func (*BufferDataPointer) Class() binary.Class {
	return (*binaryClassBufferDataPointer)(nil)
}
func doEncodeBufferDataPointer(e binary.Encoder, o *BufferDataPointer) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeBufferDataPointer(d binary.Decoder, o *BufferDataPointer) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipBufferDataPointer(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBufferDataPointer) ID() binary.ID      { return binaryIDBufferDataPointer }
func (*binaryClassBufferDataPointer) New() binary.Object { return &BufferDataPointer{} }
func (*binaryClassBufferDataPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBufferDataPointer(e, obj.(*BufferDataPointer))
}
func (*binaryClassBufferDataPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BufferDataPointer{}
	return obj, doDecodeBufferDataPointer(d, obj)
}
func (*binaryClassBufferDataPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBufferDataPointer(d, obj.(*BufferDataPointer))
}
func (*binaryClassBufferDataPointer) Skip(d binary.Decoder) error { return doSkipBufferDataPointer(d) }
func (*binaryClassBufferDataPointer) Schema() *schema.Class       { return schemaBufferDataPointer }

var schemaBufferDataPointer = &schema.Class{
	TypeID:  binaryIDBufferDataPointer,
	Package: "gles",
	Name:    "BufferDataPointer",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassBufferIdˢ struct{}

func (*BufferIdˢ) Class() binary.Class {
	return (*binaryClassBufferIdˢ)(nil)
}
func doEncodeBufferIdˢ(e binary.Encoder, o *BufferIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeBufferIdˢ(d binary.Decoder, o *BufferIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipBufferIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBufferIdˢ) ID() binary.ID      { return binaryIDBufferIdˢ }
func (*binaryClassBufferIdˢ) New() binary.Object { return &BufferIdˢ{} }
func (*binaryClassBufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBufferIdˢ(e, obj.(*BufferIdˢ))
}
func (*binaryClassBufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BufferIdˢ{}
	return obj, doDecodeBufferIdˢ(d, obj)
}
func (*binaryClassBufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBufferIdˢ(d, obj.(*BufferIdˢ))
}
func (*binaryClassBufferIdˢ) Skip(d binary.Decoder) error { return doSkipBufferIdˢ(d) }
func (*binaryClassBufferIdˢ) Schema() *schema.Class       { return schemaBufferIdˢ }

var schemaBufferIdˢ = &schema.Class{
	TypeID:  binaryIDBufferIdˢ,
	Package: "gles",
	Name:    "BufferIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassBufferIdᵖ struct{}

func (*BufferIdᵖ) Class() binary.Class {
	return (*binaryClassBufferIdᵖ)(nil)
}
func doEncodeBufferIdᵖ(e binary.Encoder, o *BufferIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeBufferIdᵖ(d binary.Decoder, o *BufferIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipBufferIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBufferIdᵖ) ID() binary.ID      { return binaryIDBufferIdᵖ }
func (*binaryClassBufferIdᵖ) New() binary.Object { return &BufferIdᵖ{} }
func (*binaryClassBufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBufferIdᵖ(e, obj.(*BufferIdᵖ))
}
func (*binaryClassBufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BufferIdᵖ{}
	return obj, doDecodeBufferIdᵖ(d, obj)
}
func (*binaryClassBufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBufferIdᵖ(d, obj.(*BufferIdᵖ))
}
func (*binaryClassBufferIdᵖ) Skip(d binary.Decoder) error { return doSkipBufferIdᵖ(d) }
func (*binaryClassBufferIdᵖ) Schema() *schema.Class       { return schemaBufferIdᵖ }

var schemaBufferIdᵖ = &schema.Class{
	TypeID:  binaryIDBufferIdᵖ,
	Package: "gles",
	Name:    "BufferIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassBufferIdᶜᵖ struct{}

func (*BufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassBufferIdᶜᵖ)(nil)
}
func doEncodeBufferIdᶜᵖ(e binary.Encoder, o *BufferIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeBufferIdᶜᵖ(d binary.Decoder, o *BufferIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipBufferIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBufferIdᶜᵖ) ID() binary.ID      { return binaryIDBufferIdᶜᵖ }
func (*binaryClassBufferIdᶜᵖ) New() binary.Object { return &BufferIdᶜᵖ{} }
func (*binaryClassBufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBufferIdᶜᵖ(e, obj.(*BufferIdᶜᵖ))
}
func (*binaryClassBufferIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BufferIdᶜᵖ{}
	return obj, doDecodeBufferIdᶜᵖ(d, obj)
}
func (*binaryClassBufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBufferIdᶜᵖ(d, obj.(*BufferIdᶜᵖ))
}
func (*binaryClassBufferIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipBufferIdᶜᵖ(d) }
func (*binaryClassBufferIdᶜᵖ) Schema() *schema.Class       { return schemaBufferIdᶜᵖ }

var schemaBufferIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDBufferIdᶜᵖ,
	Package: "gles",
	Name:    "BufferIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGLContextObj struct{}

func (*CGLContextObj) Class() binary.Class {
	return (*binaryClassCGLContextObj)(nil)
}
func doEncodeCGLContextObj(e binary.Encoder, o *CGLContextObj) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLContextObj(d binary.Decoder, o *CGLContextObj) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGLContextObj(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLContextObj) ID() binary.ID      { return binaryIDCGLContextObj }
func (*binaryClassCGLContextObj) New() binary.Object { return &CGLContextObj{} }
func (*binaryClassCGLContextObj) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLContextObj(e, obj.(*CGLContextObj))
}
func (*binaryClassCGLContextObj) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLContextObj{}
	return obj, doDecodeCGLContextObj(d, obj)
}
func (*binaryClassCGLContextObj) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLContextObj(d, obj.(*CGLContextObj))
}
func (*binaryClassCGLContextObj) Skip(d binary.Decoder) error { return doSkipCGLContextObj(d) }
func (*binaryClassCGLContextObj) Schema() *schema.Class       { return schemaCGLContextObj }

var schemaCGLContextObj = &schema.Class{
	TypeID:  binaryIDCGLContextObj,
	Package: "gles",
	Name:    "CGLContextObj",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGLContextObjˢ struct{}

func (*CGLContextObjˢ) Class() binary.Class {
	return (*binaryClassCGLContextObjˢ)(nil)
}
func doEncodeCGLContextObjˢ(e binary.Encoder, o *CGLContextObjˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLContextObjˢ(d binary.Decoder, o *CGLContextObjˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCGLContextObjˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLContextObjˢ) ID() binary.ID      { return binaryIDCGLContextObjˢ }
func (*binaryClassCGLContextObjˢ) New() binary.Object { return &CGLContextObjˢ{} }
func (*binaryClassCGLContextObjˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLContextObjˢ(e, obj.(*CGLContextObjˢ))
}
func (*binaryClassCGLContextObjˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLContextObjˢ{}
	return obj, doDecodeCGLContextObjˢ(d, obj)
}
func (*binaryClassCGLContextObjˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLContextObjˢ(d, obj.(*CGLContextObjˢ))
}
func (*binaryClassCGLContextObjˢ) Skip(d binary.Decoder) error { return doSkipCGLContextObjˢ(d) }
func (*binaryClassCGLContextObjˢ) Schema() *schema.Class       { return schemaCGLContextObjˢ }

var schemaCGLContextObjˢ = &schema.Class{
	TypeID:  binaryIDCGLContextObjˢ,
	Package: "gles",
	Name:    "CGLContextObjˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCGLContextObjᵖ struct{}

func (*CGLContextObjᵖ) Class() binary.Class {
	return (*binaryClassCGLContextObjᵖ)(nil)
}
func doEncodeCGLContextObjᵖ(e binary.Encoder, o *CGLContextObjᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLContextObjᵖ(d binary.Decoder, o *CGLContextObjᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGLContextObjᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLContextObjᵖ) ID() binary.ID      { return binaryIDCGLContextObjᵖ }
func (*binaryClassCGLContextObjᵖ) New() binary.Object { return &CGLContextObjᵖ{} }
func (*binaryClassCGLContextObjᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLContextObjᵖ(e, obj.(*CGLContextObjᵖ))
}
func (*binaryClassCGLContextObjᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLContextObjᵖ{}
	return obj, doDecodeCGLContextObjᵖ(d, obj)
}
func (*binaryClassCGLContextObjᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLContextObjᵖ(d, obj.(*CGLContextObjᵖ))
}
func (*binaryClassCGLContextObjᵖ) Skip(d binary.Decoder) error { return doSkipCGLContextObjᵖ(d) }
func (*binaryClassCGLContextObjᵖ) Schema() *schema.Class       { return schemaCGLContextObjᵖ }

var schemaCGLContextObjᵖ = &schema.Class{
	TypeID:  binaryIDCGLContextObjᵖ,
	Package: "gles",
	Name:    "CGLContextObjᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGLPixelFormatObj struct{}

func (*CGLPixelFormatObj) Class() binary.Class {
	return (*binaryClassCGLPixelFormatObj)(nil)
}
func doEncodeCGLPixelFormatObj(e binary.Encoder, o *CGLPixelFormatObj) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLPixelFormatObj(d binary.Decoder, o *CGLPixelFormatObj) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGLPixelFormatObj(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLPixelFormatObj) ID() binary.ID      { return binaryIDCGLPixelFormatObj }
func (*binaryClassCGLPixelFormatObj) New() binary.Object { return &CGLPixelFormatObj{} }
func (*binaryClassCGLPixelFormatObj) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLPixelFormatObj(e, obj.(*CGLPixelFormatObj))
}
func (*binaryClassCGLPixelFormatObj) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLPixelFormatObj{}
	return obj, doDecodeCGLPixelFormatObj(d, obj)
}
func (*binaryClassCGLPixelFormatObj) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLPixelFormatObj(d, obj.(*CGLPixelFormatObj))
}
func (*binaryClassCGLPixelFormatObj) Skip(d binary.Decoder) error { return doSkipCGLPixelFormatObj(d) }
func (*binaryClassCGLPixelFormatObj) Schema() *schema.Class       { return schemaCGLPixelFormatObj }

var schemaCGLPixelFormatObj = &schema.Class{
	TypeID:  binaryIDCGLPixelFormatObj,
	Package: "gles",
	Name:    "CGLPixelFormatObj",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGLCreateContext struct{}

func (*CGLCreateContext) Class() binary.Class {
	return (*binaryClassCGLCreateContext)(nil)
}
func doEncodeCGLCreateContext(e binary.Encoder, o *CGLCreateContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Pix); err != nil {
		return err
	}
	if err := e.Value(&o.Share); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLCreateContext(d binary.Decoder, o *CGLCreateContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Pix); err != nil {
		return err
	}
	if err := d.Value(&o.Share); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = CGLError(obj)
	}
	return nil
}
func doSkipCGLCreateContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLPixelFormatObj)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLContextObjᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLCreateContext) ID() binary.ID      { return binaryIDCGLCreateContext }
func (*binaryClassCGLCreateContext) New() binary.Object { return &CGLCreateContext{} }
func (*binaryClassCGLCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLCreateContext(e, obj.(*CGLCreateContext))
}
func (*binaryClassCGLCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLCreateContext{}
	return obj, doDecodeCGLCreateContext(d, obj)
}
func (*binaryClassCGLCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLCreateContext(d, obj.(*CGLCreateContext))
}
func (*binaryClassCGLCreateContext) Skip(d binary.Decoder) error { return doSkipCGLCreateContext(d) }
func (*binaryClassCGLCreateContext) Schema() *schema.Class       { return schemaCGLCreateContext }

var schemaCGLCreateContext = &schema.Class{
	TypeID:  binaryIDCGLCreateContext,
	Package: "gles",
	Name:    "CGLCreateContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pix", Type: &schema.Struct{Name: "CGLPixelFormatObj", ID: (*CGLPixelFormatObj)(nil).Class().ID()}},
		{Declared: "Share", Type: &schema.Struct{Name: "CGLContextObj", ID: (*CGLContextObj)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObjᵖ", ID: (*CGLContextObjᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "CGLError", Method: schema.Int64}},
	},
}

type binaryClassCGLFlushDrawable struct{}

func (*CGLFlushDrawable) Class() binary.Class {
	return (*binaryClassCGLFlushDrawable)(nil)
}
func doEncodeCGLFlushDrawable(e binary.Encoder, o *CGLFlushDrawable) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLFlushDrawable(d binary.Decoder, o *CGLFlushDrawable) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = CGLError(obj)
	}
	return nil
}
func doSkipCGLFlushDrawable(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLFlushDrawable) ID() binary.ID      { return binaryIDCGLFlushDrawable }
func (*binaryClassCGLFlushDrawable) New() binary.Object { return &CGLFlushDrawable{} }
func (*binaryClassCGLFlushDrawable) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLFlushDrawable(e, obj.(*CGLFlushDrawable))
}
func (*binaryClassCGLFlushDrawable) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLFlushDrawable{}
	return obj, doDecodeCGLFlushDrawable(d, obj)
}
func (*binaryClassCGLFlushDrawable) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLFlushDrawable(d, obj.(*CGLFlushDrawable))
}
func (*binaryClassCGLFlushDrawable) Skip(d binary.Decoder) error { return doSkipCGLFlushDrawable(d) }
func (*binaryClassCGLFlushDrawable) Schema() *schema.Class       { return schemaCGLFlushDrawable }

var schemaCGLFlushDrawable = &schema.Class{
	TypeID:  binaryIDCGLFlushDrawable,
	Package: "gles",
	Name:    "CGLFlushDrawable",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObj", ID: (*CGLContextObj)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "CGLError", Method: schema.Int64}},
	},
}

type binaryClassCGSConnectionIDᵖ struct{}

func (*CGSConnectionIDᵖ) Class() binary.Class {
	return (*binaryClassCGSConnectionIDᵖ)(nil)
}
func doEncodeCGSConnectionIDᵖ(e binary.Encoder, o *CGSConnectionIDᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSConnectionIDᵖ(d binary.Decoder, o *CGSConnectionIDᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGSConnectionIDᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSConnectionIDᵖ) ID() binary.ID      { return binaryIDCGSConnectionIDᵖ }
func (*binaryClassCGSConnectionIDᵖ) New() binary.Object { return &CGSConnectionIDᵖ{} }
func (*binaryClassCGSConnectionIDᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSConnectionIDᵖ(e, obj.(*CGSConnectionIDᵖ))
}
func (*binaryClassCGSConnectionIDᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSConnectionIDᵖ{}
	return obj, doDecodeCGSConnectionIDᵖ(d, obj)
}
func (*binaryClassCGSConnectionIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSConnectionIDᵖ(d, obj.(*CGSConnectionIDᵖ))
}
func (*binaryClassCGSConnectionIDᵖ) Skip(d binary.Decoder) error { return doSkipCGSConnectionIDᵖ(d) }
func (*binaryClassCGSConnectionIDᵖ) Schema() *schema.Class       { return schemaCGSConnectionIDᵖ }

var schemaCGSConnectionIDᵖ = &schema.Class{
	TypeID:  binaryIDCGSConnectionIDᵖ,
	Package: "gles",
	Name:    "CGSConnectionIDᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGSWindowIDᵖ struct{}

func (*CGSWindowIDᵖ) Class() binary.Class {
	return (*binaryClassCGSWindowIDᵖ)(nil)
}
func doEncodeCGSWindowIDᵖ(e binary.Encoder, o *CGSWindowIDᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSWindowIDᵖ(d binary.Decoder, o *CGSWindowIDᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGSWindowIDᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSWindowIDᵖ) ID() binary.ID      { return binaryIDCGSWindowIDᵖ }
func (*binaryClassCGSWindowIDᵖ) New() binary.Object { return &CGSWindowIDᵖ{} }
func (*binaryClassCGSWindowIDᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSWindowIDᵖ(e, obj.(*CGSWindowIDᵖ))
}
func (*binaryClassCGSWindowIDᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSWindowIDᵖ{}
	return obj, doDecodeCGSWindowIDᵖ(d, obj)
}
func (*binaryClassCGSWindowIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSWindowIDᵖ(d, obj.(*CGSWindowIDᵖ))
}
func (*binaryClassCGSWindowIDᵖ) Skip(d binary.Decoder) error { return doSkipCGSWindowIDᵖ(d) }
func (*binaryClassCGSWindowIDᵖ) Schema() *schema.Class       { return schemaCGSWindowIDᵖ }

var schemaCGSWindowIDᵖ = &schema.Class{
	TypeID:  binaryIDCGSWindowIDᵖ,
	Package: "gles",
	Name:    "CGSWindowIDᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGSSurfaceIDᵖ struct{}

func (*CGSSurfaceIDᵖ) Class() binary.Class {
	return (*binaryClassCGSSurfaceIDᵖ)(nil)
}
func doEncodeCGSSurfaceIDᵖ(e binary.Encoder, o *CGSSurfaceIDᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSSurfaceIDᵖ(d binary.Decoder, o *CGSSurfaceIDᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGSSurfaceIDᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSSurfaceIDᵖ) ID() binary.ID      { return binaryIDCGSSurfaceIDᵖ }
func (*binaryClassCGSSurfaceIDᵖ) New() binary.Object { return &CGSSurfaceIDᵖ{} }
func (*binaryClassCGSSurfaceIDᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSSurfaceIDᵖ(e, obj.(*CGSSurfaceIDᵖ))
}
func (*binaryClassCGSSurfaceIDᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSSurfaceIDᵖ{}
	return obj, doDecodeCGSSurfaceIDᵖ(d, obj)
}
func (*binaryClassCGSSurfaceIDᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSSurfaceIDᵖ(d, obj.(*CGSSurfaceIDᵖ))
}
func (*binaryClassCGSSurfaceIDᵖ) Skip(d binary.Decoder) error { return doSkipCGSSurfaceIDᵖ(d) }
func (*binaryClassCGSSurfaceIDᵖ) Schema() *schema.Class       { return schemaCGSSurfaceIDᵖ }

var schemaCGSSurfaceIDᵖ = &schema.Class{
	TypeID:  binaryIDCGSSurfaceIDᵖ,
	Package: "gles",
	Name:    "CGSSurfaceIDᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGLGetSurface struct{}

func (*CGLGetSurface) Class() binary.Class {
	return (*binaryClassCGLGetSurface)(nil)
}
func doEncodeCGLGetSurface(e binary.Encoder, o *CGLGetSurface) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Value(&o.Cid); err != nil {
		return err
	}
	if err := e.Value(&o.Wid); err != nil {
		return err
	}
	if err := e.Value(&o.Sid); err != nil {
		return err
	}
	if err := e.Int64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLGetSurface(d binary.Decoder, o *CGLGetSurface) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if err := d.Value(&o.Cid); err != nil {
		return err
	}
	if err := d.Value(&o.Wid); err != nil {
		return err
	}
	if err := d.Value(&o.Sid); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = int64(obj)
	}
	return nil
}
func doSkipCGLGetSurface(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGSConnectionIDᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGSWindowIDᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGSSurfaceIDᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLGetSurface) ID() binary.ID      { return binaryIDCGLGetSurface }
func (*binaryClassCGLGetSurface) New() binary.Object { return &CGLGetSurface{} }
func (*binaryClassCGLGetSurface) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLGetSurface(e, obj.(*CGLGetSurface))
}
func (*binaryClassCGLGetSurface) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLGetSurface{}
	return obj, doDecodeCGLGetSurface(d, obj)
}
func (*binaryClassCGLGetSurface) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLGetSurface(d, obj.(*CGLGetSurface))
}
func (*binaryClassCGLGetSurface) Skip(d binary.Decoder) error { return doSkipCGLGetSurface(d) }
func (*binaryClassCGLGetSurface) Schema() *schema.Class       { return schemaCGLGetSurface }

var schemaCGLGetSurface = &schema.Class{
	TypeID:  binaryIDCGLGetSurface,
	Package: "gles",
	Name:    "CGLGetSurface",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObj", ID: (*CGLContextObj)(nil).Class().ID()}},
		{Declared: "Cid", Type: &schema.Struct{Name: "CGSConnectionIDᵖ", ID: (*CGSConnectionIDᵖ)(nil).Class().ID()}},
		{Declared: "Wid", Type: &schema.Struct{Name: "CGSWindowIDᵖ", ID: (*CGSWindowIDᵖ)(nil).Class().ID()}},
		{Declared: "Sid", Type: &schema.Struct{Name: "CGSSurfaceIDᵖ", ID: (*CGSSurfaceIDᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassCGLSetCurrentContext struct{}

func (*CGLSetCurrentContext) Class() binary.Class {
	return (*binaryClassCGLSetCurrentContext)(nil)
}
func doEncodeCGLSetCurrentContext(e binary.Encoder, o *CGLSetCurrentContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeCGLSetCurrentContext(d binary.Decoder, o *CGLSetCurrentContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = CGLError(obj)
	}
	return nil
}
func doSkipCGLSetCurrentContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGLSetCurrentContext) ID() binary.ID      { return binaryIDCGLSetCurrentContext }
func (*binaryClassCGLSetCurrentContext) New() binary.Object { return &CGLSetCurrentContext{} }
func (*binaryClassCGLSetCurrentContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGLSetCurrentContext(e, obj.(*CGLSetCurrentContext))
}
func (*binaryClassCGLSetCurrentContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGLSetCurrentContext{}
	return obj, doDecodeCGLSetCurrentContext(d, obj)
}
func (*binaryClassCGLSetCurrentContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGLSetCurrentContext(d, obj.(*CGLSetCurrentContext))
}
func (*binaryClassCGLSetCurrentContext) Skip(d binary.Decoder) error {
	return doSkipCGLSetCurrentContext(d)
}
func (*binaryClassCGLSetCurrentContext) Schema() *schema.Class { return schemaCGLSetCurrentContext }

var schemaCGLSetCurrentContext = &schema.Class{
	TypeID:  binaryIDCGLSetCurrentContext,
	Package: "gles",
	Name:    "CGLSetCurrentContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "CGLContextObj", ID: (*CGLContextObj)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "CGLError", Method: schema.Int64}},
	},
}

type binaryClassCGSConnectionID struct{}

func (*CGSConnectionID) Class() binary.Class {
	return (*binaryClassCGSConnectionID)(nil)
}
func doEncodeCGSConnectionID(e binary.Encoder, o *CGSConnectionID) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSConnectionID(d binary.Decoder, o *CGSConnectionID) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCGSConnectionID(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSConnectionID) ID() binary.ID      { return binaryIDCGSConnectionID }
func (*binaryClassCGSConnectionID) New() binary.Object { return &CGSConnectionID{} }
func (*binaryClassCGSConnectionID) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSConnectionID(e, obj.(*CGSConnectionID))
}
func (*binaryClassCGSConnectionID) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSConnectionID{}
	return obj, doDecodeCGSConnectionID(d, obj)
}
func (*binaryClassCGSConnectionID) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSConnectionID(d, obj.(*CGSConnectionID))
}
func (*binaryClassCGSConnectionID) Skip(d binary.Decoder) error { return doSkipCGSConnectionID(d) }
func (*binaryClassCGSConnectionID) Schema() *schema.Class       { return schemaCGSConnectionID }

var schemaCGSConnectionID = &schema.Class{
	TypeID:  binaryIDCGSConnectionID,
	Package: "gles",
	Name:    "CGSConnectionID",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGSConnectionIDˢ struct{}

func (*CGSConnectionIDˢ) Class() binary.Class {
	return (*binaryClassCGSConnectionIDˢ)(nil)
}
func doEncodeCGSConnectionIDˢ(e binary.Encoder, o *CGSConnectionIDˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSConnectionIDˢ(d binary.Decoder, o *CGSConnectionIDˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCGSConnectionIDˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSConnectionIDˢ) ID() binary.ID      { return binaryIDCGSConnectionIDˢ }
func (*binaryClassCGSConnectionIDˢ) New() binary.Object { return &CGSConnectionIDˢ{} }
func (*binaryClassCGSConnectionIDˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSConnectionIDˢ(e, obj.(*CGSConnectionIDˢ))
}
func (*binaryClassCGSConnectionIDˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSConnectionIDˢ{}
	return obj, doDecodeCGSConnectionIDˢ(d, obj)
}
func (*binaryClassCGSConnectionIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSConnectionIDˢ(d, obj.(*CGSConnectionIDˢ))
}
func (*binaryClassCGSConnectionIDˢ) Skip(d binary.Decoder) error { return doSkipCGSConnectionIDˢ(d) }
func (*binaryClassCGSConnectionIDˢ) Schema() *schema.Class       { return schemaCGSConnectionIDˢ }

var schemaCGSConnectionIDˢ = &schema.Class{
	TypeID:  binaryIDCGSConnectionIDˢ,
	Package: "gles",
	Name:    "CGSConnectionIDˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassF64ᵖ struct{}

func (*F64ᵖ) Class() binary.Class {
	return (*binaryClassF64ᵖ)(nil)
}
func doEncodeF64ᵖ(e binary.Encoder, o *F64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeF64ᵖ(d binary.Decoder, o *F64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipF64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF64ᵖ) ID() binary.ID      { return binaryIDF64ᵖ }
func (*binaryClassF64ᵖ) New() binary.Object { return &F64ᵖ{} }
func (*binaryClassF64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF64ᵖ(e, obj.(*F64ᵖ))
}
func (*binaryClassF64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F64ᵖ{}
	return obj, doDecodeF64ᵖ(d, obj)
}
func (*binaryClassF64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF64ᵖ(d, obj.(*F64ᵖ))
}
func (*binaryClassF64ᵖ) Skip(d binary.Decoder) error { return doSkipF64ᵖ(d) }
func (*binaryClassF64ᵖ) Schema() *schema.Class       { return schemaF64ᵖ }

var schemaF64ᵖ = &schema.Class{
	TypeID:  binaryIDF64ᵖ,
	Package: "gles",
	Name:    "F64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCGSGetSurfaceBounds struct{}

func (*CGSGetSurfaceBounds) Class() binary.Class {
	return (*binaryClassCGSGetSurfaceBounds)(nil)
}
func doEncodeCGSGetSurfaceBounds(e binary.Encoder, o *CGSGetSurfaceBounds) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Cid); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Wid)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Sid)); err != nil {
		return err
	}
	if err := e.Value(&o.Bounds); err != nil {
		return err
	}
	if err := e.Int64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSGetSurfaceBounds(d binary.Decoder, o *CGSGetSurfaceBounds) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Cid); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Wid = CGSWindowID(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Sid = CGSSurfaceID(obj)
	}
	if err := d.Value(&o.Bounds); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = int64(obj)
	}
	return nil
}
func doSkipCGSGetSurfaceBounds(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CGSConnectionID)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*F64ᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSGetSurfaceBounds) ID() binary.ID      { return binaryIDCGSGetSurfaceBounds }
func (*binaryClassCGSGetSurfaceBounds) New() binary.Object { return &CGSGetSurfaceBounds{} }
func (*binaryClassCGSGetSurfaceBounds) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSGetSurfaceBounds(e, obj.(*CGSGetSurfaceBounds))
}
func (*binaryClassCGSGetSurfaceBounds) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSGetSurfaceBounds{}
	return obj, doDecodeCGSGetSurfaceBounds(d, obj)
}
func (*binaryClassCGSGetSurfaceBounds) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSGetSurfaceBounds(d, obj.(*CGSGetSurfaceBounds))
}
func (*binaryClassCGSGetSurfaceBounds) Skip(d binary.Decoder) error {
	return doSkipCGSGetSurfaceBounds(d)
}
func (*binaryClassCGSGetSurfaceBounds) Schema() *schema.Class { return schemaCGSGetSurfaceBounds }

var schemaCGSGetSurfaceBounds = &schema.Class{
	TypeID:  binaryIDCGSGetSurfaceBounds,
	Package: "gles",
	Name:    "CGSGetSurfaceBounds",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Cid", Type: &schema.Struct{Name: "CGSConnectionID", ID: (*CGSConnectionID)(nil).Class().ID()}},
		{Declared: "Wid", Type: &schema.Primitive{Name: "CGSWindowID", Method: schema.Int32}},
		{Declared: "Sid", Type: &schema.Primitive{Name: "CGSSurfaceID", Method: schema.Int32}},
		{Declared: "Bounds", Type: &schema.Struct{Name: "F64ᵖ", ID: (*F64ᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassCGSSurfaceIDˢ struct{}

func (*CGSSurfaceIDˢ) Class() binary.Class {
	return (*binaryClassCGSSurfaceIDˢ)(nil)
}
func doEncodeCGSSurfaceIDˢ(e binary.Encoder, o *CGSSurfaceIDˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSSurfaceIDˢ(d binary.Decoder, o *CGSSurfaceIDˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCGSSurfaceIDˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSSurfaceIDˢ) ID() binary.ID      { return binaryIDCGSSurfaceIDˢ }
func (*binaryClassCGSSurfaceIDˢ) New() binary.Object { return &CGSSurfaceIDˢ{} }
func (*binaryClassCGSSurfaceIDˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSSurfaceIDˢ(e, obj.(*CGSSurfaceIDˢ))
}
func (*binaryClassCGSSurfaceIDˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSSurfaceIDˢ{}
	return obj, doDecodeCGSSurfaceIDˢ(d, obj)
}
func (*binaryClassCGSSurfaceIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSSurfaceIDˢ(d, obj.(*CGSSurfaceIDˢ))
}
func (*binaryClassCGSSurfaceIDˢ) Skip(d binary.Decoder) error { return doSkipCGSSurfaceIDˢ(d) }
func (*binaryClassCGSSurfaceIDˢ) Schema() *schema.Class       { return schemaCGSSurfaceIDˢ }

var schemaCGSSurfaceIDˢ = &schema.Class{
	TypeID:  binaryIDCGSSurfaceIDˢ,
	Package: "gles",
	Name:    "CGSSurfaceIDˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCGSWindowIDˢ struct{}

func (*CGSWindowIDˢ) Class() binary.Class {
	return (*binaryClassCGSWindowIDˢ)(nil)
}
func doEncodeCGSWindowIDˢ(e binary.Encoder, o *CGSWindowIDˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCGSWindowIDˢ(d binary.Decoder, o *CGSWindowIDˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCGSWindowIDˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCGSWindowIDˢ) ID() binary.ID      { return binaryIDCGSWindowIDˢ }
func (*binaryClassCGSWindowIDˢ) New() binary.Object { return &CGSWindowIDˢ{} }
func (*binaryClassCGSWindowIDˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCGSWindowIDˢ(e, obj.(*CGSWindowIDˢ))
}
func (*binaryClassCGSWindowIDˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CGSWindowIDˢ{}
	return obj, doDecodeCGSWindowIDˢ(d, obj)
}
func (*binaryClassCGSWindowIDˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCGSWindowIDˢ(d, obj.(*CGSWindowIDˢ))
}
func (*binaryClassCGSWindowIDˢ) Skip(d binary.Decoder) error { return doSkipCGSWindowIDˢ(d) }
func (*binaryClassCGSWindowIDˢ) Schema() *schema.Class       { return schemaCGSWindowIDˢ }

var schemaCGSWindowIDˢ = &schema.Class{
	TypeID:  binaryIDCGSWindowIDˢ,
	Package: "gles",
	Name:    "CGSWindowIDˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCharˢ struct{}

func (*Charˢ) Class() binary.Class {
	return (*binaryClassCharˢ)(nil)
}
func doEncodeCharˢ(e binary.Encoder, o *Charˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCharˢ(d binary.Decoder, o *Charˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCharˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharˢ) ID() binary.ID      { return binaryIDCharˢ }
func (*binaryClassCharˢ) New() binary.Object { return &Charˢ{} }
func (*binaryClassCharˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharˢ(e, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charˢ{}
	return obj, doDecodeCharˢ(d, obj)
}
func (*binaryClassCharˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharˢ(d, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Skip(d binary.Decoder) error { return doSkipCharˢ(d) }
func (*binaryClassCharˢ) Schema() *schema.Class       { return schemaCharˢ }

var schemaCharˢ = &schema.Class{
	TypeID:  binaryIDCharˢ,
	Package: "gles",
	Name:    "Charˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCharᵖ struct{}

func (*Charᵖ) Class() binary.Class {
	return (*binaryClassCharᵖ)(nil)
}
func doEncodeCharᵖ(e binary.Encoder, o *Charᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCharᵖ(d binary.Decoder, o *Charᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCharᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharᵖ) ID() binary.ID      { return binaryIDCharᵖ }
func (*binaryClassCharᵖ) New() binary.Object { return &Charᵖ{} }
func (*binaryClassCharᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharᵖ(e, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charᵖ{}
	return obj, doDecodeCharᵖ(d, obj)
}
func (*binaryClassCharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharᵖ(d, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Skip(d binary.Decoder) error { return doSkipCharᵖ(d) }
func (*binaryClassCharᵖ) Schema() *schema.Class       { return schemaCharᵖ }

var schemaCharᵖ = &schema.Class{
	TypeID:  binaryIDCharᵖ,
	Package: "gles",
	Name:    "Charᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassClearState struct{}

func (*ClearState) Class() binary.Class {
	return (*binaryClassClearState)(nil)
}
func doEncodeClearState(e binary.Encoder, o *ClearState) error {
	if err := e.Value(&o.ClearColor); err != nil {
		return err
	}
	if err := e.Float32(float32(o.ClearDepth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ClearStencil)); err != nil {
		return err
	}
	return nil
}
func doDecodeClearState(d binary.Decoder, o *ClearState) error {
	if err := d.Value(&o.ClearColor); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.ClearDepth = GLfloat(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ClearStencil = GLint(obj)
	}
	return nil
}
func doSkipClearState(d binary.Decoder) error {
	if err := d.SkipValue((*Color)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassClearState) ID() binary.ID      { return binaryIDClearState }
func (*binaryClassClearState) New() binary.Object { return &ClearState{} }
func (*binaryClassClearState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeClearState(e, obj.(*ClearState))
}
func (*binaryClassClearState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ClearState{}
	return obj, doDecodeClearState(d, obj)
}
func (*binaryClassClearState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeClearState(d, obj.(*ClearState))
}
func (*binaryClassClearState) Skip(d binary.Decoder) error { return doSkipClearState(d) }
func (*binaryClassClearState) Schema() *schema.Class       { return schemaClearState }

var schemaClearState = &schema.Class{
	TypeID:  binaryIDClearState,
	Package: "gles",
	Name:    "ClearState",
	Fields: []schema.Field{
		{Declared: "ClearColor", Type: &schema.Struct{Name: "Color", ID: (*Color)(nil).Class().ID()}},
		{Declared: "ClearDepth", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "ClearStencil", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassRect struct{}

func (*Rect) Class() binary.Class {
	return (*binaryClassRect)(nil)
}
func doEncodeRect(e binary.Encoder, o *Rect) error {
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeRect(d binary.Decoder, o *Rect) error {
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipRect(d binary.Decoder) error {
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRect) ID() binary.ID      { return binaryIDRect }
func (*binaryClassRect) New() binary.Object { return &Rect{} }
func (*binaryClassRect) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRect(e, obj.(*Rect))
}
func (*binaryClassRect) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Rect{}
	return obj, doDecodeRect(d, obj)
}
func (*binaryClassRect) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRect(d, obj.(*Rect))
}
func (*binaryClassRect) Skip(d binary.Decoder) error { return doSkipRect(d) }
func (*binaryClassRect) Schema() *schema.Class       { return schemaRect }

var schemaRect = &schema.Class{
	TypeID:  binaryIDRect,
	Package: "gles",
	Name:    "Rect",
	Fields: []schema.Field{
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassRasterizerState struct{}

func (*RasterizerState) Class() binary.Class {
	return (*binaryClassRasterizerState)(nil)
}
func doEncodeRasterizerState(e binary.Encoder, o *RasterizerState) error {
	if err := e.Uint8(uint8(o.DepthMask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DepthTestFunction)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.DepthNear)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.DepthFar)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.ColorMaskRed)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.ColorMaskGreen)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.ColorMaskBlue)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.ColorMaskAlpha)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.StencilMask))); err != nil {
		return err
	}
	for k, v := range o.StencilMask {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Value(&o.Viewport); err != nil {
		return err
	}
	if err := e.Value(&o.Scissor); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FrontFace)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CullFace)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.LineWidth)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.PolygonOffsetFactor)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.PolygonOffsetUnits)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.SampleCoverageValue)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.SampleCoverageInvert)); err != nil {
		return err
	}
	return nil
}
func doDecodeRasterizerState(d binary.Decoder, o *RasterizerState) error {
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.DepthMask = GLboolean(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DepthTestFunction = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.DepthNear = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.DepthFar = GLfloat(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.ColorMaskRed = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.ColorMaskGreen = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.ColorMaskBlue = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.ColorMaskAlpha = GLboolean(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.StencilMask = make(GLenumːGLuintᵐ, count)
		m := o.StencilMask
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v GLuint
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = GLuint(obj)
			}
			m[k] = v
		}
	}
	if err := d.Value(&o.Viewport); err != nil {
		return err
	}
	if err := d.Value(&o.Scissor); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FrontFace = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CullFace = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.LineWidth = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.PolygonOffsetFactor = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.PolygonOffsetUnits = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.SampleCoverageValue = GLfloat(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.SampleCoverageInvert = GLboolean(obj)
	}
	return nil
}
func doSkipRasterizerState(d binary.Decoder) error {
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if err := d.SkipValue((*Rect)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Rect)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRasterizerState) ID() binary.ID      { return binaryIDRasterizerState }
func (*binaryClassRasterizerState) New() binary.Object { return &RasterizerState{} }
func (*binaryClassRasterizerState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRasterizerState(e, obj.(*RasterizerState))
}
func (*binaryClassRasterizerState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RasterizerState{}
	return obj, doDecodeRasterizerState(d, obj)
}
func (*binaryClassRasterizerState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRasterizerState(d, obj.(*RasterizerState))
}
func (*binaryClassRasterizerState) Skip(d binary.Decoder) error { return doSkipRasterizerState(d) }
func (*binaryClassRasterizerState) Schema() *schema.Class       { return schemaRasterizerState }

var schemaRasterizerState = &schema.Class{
	TypeID:  binaryIDRasterizerState,
	Package: "gles",
	Name:    "RasterizerState",
	Fields: []schema.Field{
		{Declared: "DepthMask", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "DepthTestFunction", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DepthNear", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "DepthFar", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "ColorMaskRed", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "ColorMaskGreen", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "ColorMaskBlue", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "ColorMaskAlpha", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "StencilMask", Type: &schema.Map{Alias: "GLenumːGLuintᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}},
		{Declared: "Viewport", Type: &schema.Struct{Name: "Rect", ID: (*Rect)(nil).Class().ID()}},
		{Declared: "Scissor", Type: &schema.Struct{Name: "Rect", ID: (*Rect)(nil).Class().ID()}},
		{Declared: "FrontFace", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "CullFace", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "LineWidth", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "PolygonOffsetFactor", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "PolygonOffsetUnits", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "SampleCoverageValue", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "SampleCoverageInvert", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassVertexPointer struct{}

func (*VertexPointer) Class() binary.Class {
	return (*binaryClassVertexPointer)(nil)
}
func doEncodeVertexPointer(e binary.Encoder, o *VertexPointer) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexPointer(d binary.Decoder, o *VertexPointer) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVertexPointer(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexPointer) ID() binary.ID      { return binaryIDVertexPointer }
func (*binaryClassVertexPointer) New() binary.Object { return &VertexPointer{} }
func (*binaryClassVertexPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexPointer(e, obj.(*VertexPointer))
}
func (*binaryClassVertexPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexPointer{}
	return obj, doDecodeVertexPointer(d, obj)
}
func (*binaryClassVertexPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexPointer(d, obj.(*VertexPointer))
}
func (*binaryClassVertexPointer) Skip(d binary.Decoder) error { return doSkipVertexPointer(d) }
func (*binaryClassVertexPointer) Schema() *schema.Class       { return schemaVertexPointer }

var schemaVertexPointer = &schema.Class{
	TypeID:  binaryIDVertexPointer,
	Package: "gles",
	Name:    "VertexPointer",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVertexAttributeArray struct{}

func (*VertexAttributeArray) Class() binary.Class {
	return (*binaryClassVertexAttributeArray)(nil)
}
func doEncodeVertexAttributeArray(e binary.Encoder, o *VertexAttributeArray) error {
	if err := e.Bool(o.Enabled); err != nil {
		return err
	}
	if err := e.Uint32(o.Size); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Normalized)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexAttributeArray(d binary.Decoder, o *VertexAttributeArray) error {
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Enabled = bool(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Size = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Normalized = GLboolean(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVertexAttributeArray(d binary.Decoder) error {
	if _, err := d.Bool(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexPointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexAttributeArray) ID() binary.ID      { return binaryIDVertexAttributeArray }
func (*binaryClassVertexAttributeArray) New() binary.Object { return &VertexAttributeArray{} }
func (*binaryClassVertexAttributeArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexAttributeArray(e, obj.(*VertexAttributeArray))
}
func (*binaryClassVertexAttributeArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexAttributeArray{}
	return obj, doDecodeVertexAttributeArray(d, obj)
}
func (*binaryClassVertexAttributeArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexAttributeArray(d, obj.(*VertexAttributeArray))
}
func (*binaryClassVertexAttributeArray) Skip(d binary.Decoder) error {
	return doSkipVertexAttributeArray(d)
}
func (*binaryClassVertexAttributeArray) Schema() *schema.Class { return schemaVertexAttributeArray }

var schemaVertexAttributeArray = &schema.Class{
	TypeID:  binaryIDVertexAttributeArray,
	Package: "gles",
	Name:    "VertexAttributeArray",
	Fields: []schema.Field{
		{Declared: "Enabled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Normalized", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Pointer", Type: &schema.Struct{Name: "VertexPointer", ID: (*VertexPointer)(nil).Class().ID()}},
	},
}

type binaryClassRenderbuffer struct{}

func (*Renderbuffer) Class() binary.Class {
	return (*binaryClassRenderbuffer)(nil)
}
func doEncodeRenderbuffer(e binary.Encoder, o *Renderbuffer) error {
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderbuffer(d binary.Decoder, o *Renderbuffer) error {
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	return nil
}
func doSkipRenderbuffer(d binary.Decoder) error {
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderbuffer) ID() binary.ID      { return binaryIDRenderbuffer }
func (*binaryClassRenderbuffer) New() binary.Object { return &Renderbuffer{} }
func (*binaryClassRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderbuffer(e, obj.(*Renderbuffer))
}
func (*binaryClassRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Renderbuffer{}
	return obj, doDecodeRenderbuffer(d, obj)
}
func (*binaryClassRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderbuffer(d, obj.(*Renderbuffer))
}
func (*binaryClassRenderbuffer) Skip(d binary.Decoder) error { return doSkipRenderbuffer(d) }
func (*binaryClassRenderbuffer) Schema() *schema.Class       { return schemaRenderbuffer }

var schemaRenderbuffer = &schema.Class{
	TypeID:  binaryIDRenderbuffer,
	Package: "gles",
	Name:    "Renderbuffer",
	Fields: []schema.Field{
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassImage struct{}

func (*Image) Class() binary.Class {
	return (*binaryClassImage)(nil)
}
func doEncodeImage(e binary.Encoder, o *Image) error {
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Uint32(o.Size); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	return nil
}
func doDecodeImage(d binary.Decoder, o *Image) error {
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Size = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	return nil
}
func doSkipImage(d binary.Decoder) error {
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassImage) ID() binary.ID      { return binaryIDImage }
func (*binaryClassImage) New() binary.Object { return &Image{} }
func (*binaryClassImage) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeImage(e, obj.(*Image))
}
func (*binaryClassImage) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Image{}
	return obj, doDecodeImage(d, obj)
}
func (*binaryClassImage) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeImage(d, obj.(*Image))
}
func (*binaryClassImage) Skip(d binary.Decoder) error { return doSkipImage(d) }
func (*binaryClassImage) Schema() *schema.Class       { return schemaImage }

var schemaImage = &schema.Class{
	TypeID:  binaryIDImage,
	Package: "gles",
	Name:    "Image",
	Fields: []schema.Field{
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassCubemapLevel struct{}

func (*CubemapLevel) Class() binary.Class {
	return (*binaryClassCubemapLevel)(nil)
}
func doEncodeCubemapLevel(e binary.Encoder, o *CubemapLevel) error {
	if err := e.Uint32(uint32(len(o.Faces))); err != nil {
		return err
	}
	for k, v := range o.Faces {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeCubemapLevel(d binary.Decoder, o *CubemapLevel) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Faces = make(GLenumːImageᵐ, count)
		m := o.Faces
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v Image
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	return nil
}
func doSkipCubemapLevel(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if err := d.SkipValue((*Image)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassCubemapLevel) ID() binary.ID      { return binaryIDCubemapLevel }
func (*binaryClassCubemapLevel) New() binary.Object { return &CubemapLevel{} }
func (*binaryClassCubemapLevel) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCubemapLevel(e, obj.(*CubemapLevel))
}
func (*binaryClassCubemapLevel) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CubemapLevel{}
	return obj, doDecodeCubemapLevel(d, obj)
}
func (*binaryClassCubemapLevel) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCubemapLevel(d, obj.(*CubemapLevel))
}
func (*binaryClassCubemapLevel) Skip(d binary.Decoder) error { return doSkipCubemapLevel(d) }
func (*binaryClassCubemapLevel) Schema() *schema.Class       { return schemaCubemapLevel }

var schemaCubemapLevel = &schema.Class{
	TypeID:  binaryIDCubemapLevel,
	Package: "gles",
	Name:    "CubemapLevel",
	Fields: []schema.Field{
		{Declared: "Faces", Type: &schema.Map{Alias: "GLenumːImageᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Struct{Name: "Image", ID: (*Image)(nil).Class().ID()}}},
	},
}

type binaryClassTexture struct{}

func (*Texture) Class() binary.Class {
	return (*binaryClassTexture)(nil)
}
func doEncodeTexture(e binary.Encoder, o *Texture) error {
	if err := e.Uint32(uint32(o.Kind)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Texture2D))); err != nil {
		return err
	}
	for k, v := range o.Texture2D {
		if err := e.Int32(int32(k)); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Cubemap))); err != nil {
		return err
	}
	for k, v := range o.Cubemap {
		if err := e.Int32(int32(k)); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(o.MagFilter)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MinFilter)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.WrapS)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.WrapT)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SwizzleR)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SwizzleG)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SwizzleB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SwizzleA)); err != nil {
		return err
	}
	if err := e.Float32(o.MaxAnisotropy); err != nil {
		return err
	}
	return nil
}
func doDecodeTexture(d binary.Decoder, o *Texture) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Kind = TextureKind(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture2D = make(GLintːImageᵐ, count)
		m := o.Texture2D
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v Image
			if obj, err := d.Int32(); err != nil {
				return err
			} else {
				k = GLint(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Cubemap = make(GLintːCubemapLevelᵐ, count)
		m := o.Cubemap
		for i := uint32(0); i < count; i++ {
			var k GLint
			var v CubemapLevel
			if obj, err := d.Int32(); err != nil {
				return err
			} else {
				k = GLint(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MagFilter = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MinFilter = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.WrapS = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.WrapT = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SwizzleR = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SwizzleG = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SwizzleB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SwizzleA = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxAnisotropy = float32(obj)
	}
	return nil
}
func doSkipTexture(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Int32(); err != nil {
				return err
			}
			if err := d.SkipValue((*Image)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Int32(); err != nil {
				return err
			}
			if err := d.SkipValue((*CubemapLevel)(nil)); err != nil {
				return err
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTexture) ID() binary.ID      { return binaryIDTexture }
func (*binaryClassTexture) New() binary.Object { return &Texture{} }
func (*binaryClassTexture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTexture(e, obj.(*Texture))
}
func (*binaryClassTexture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Texture{}
	return obj, doDecodeTexture(d, obj)
}
func (*binaryClassTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTexture(d, obj.(*Texture))
}
func (*binaryClassTexture) Skip(d binary.Decoder) error { return doSkipTexture(d) }
func (*binaryClassTexture) Schema() *schema.Class       { return schemaTexture }

var schemaTexture = &schema.Class{
	TypeID:  binaryIDTexture,
	Package: "gles",
	Name:    "Texture",
	Fields: []schema.Field{
		{Declared: "Kind", Type: &schema.Primitive{Name: "TextureKind", Method: schema.Uint32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture2D", Type: &schema.Map{Alias: "GLintːImageᵐ", KeyType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, ValueType: &schema.Struct{Name: "Image", ID: (*Image)(nil).Class().ID()}}},
		{Declared: "Cubemap", Type: &schema.Map{Alias: "GLintːCubemapLevelᵐ", KeyType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, ValueType: &schema.Struct{Name: "CubemapLevel", ID: (*CubemapLevel)(nil).Class().ID()}}},
		{Declared: "MagFilter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "MinFilter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "WrapS", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "WrapT", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SwizzleR", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SwizzleG", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SwizzleB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SwizzleA", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "MaxAnisotropy", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
	},
}

type binaryClassFramebufferAttachmentInfo struct{}

func (*FramebufferAttachmentInfo) Class() binary.Class {
	return (*binaryClassFramebufferAttachmentInfo)(nil)
}
func doEncodeFramebufferAttachmentInfo(e binary.Encoder, o *FramebufferAttachmentInfo) error {
	if err := e.Uint32(o.Object); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.TextureLevel)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CubeMapFace)); err != nil {
		return err
	}
	return nil
}
func doDecodeFramebufferAttachmentInfo(d binary.Decoder, o *FramebufferAttachmentInfo) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Object = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.TextureLevel = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CubeMapFace = GLenum(obj)
	}
	return nil
}
func doSkipFramebufferAttachmentInfo(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFramebufferAttachmentInfo) ID() binary.ID      { return binaryIDFramebufferAttachmentInfo }
func (*binaryClassFramebufferAttachmentInfo) New() binary.Object { return &FramebufferAttachmentInfo{} }
func (*binaryClassFramebufferAttachmentInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFramebufferAttachmentInfo(e, obj.(*FramebufferAttachmentInfo))
}
func (*binaryClassFramebufferAttachmentInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FramebufferAttachmentInfo{}
	return obj, doDecodeFramebufferAttachmentInfo(d, obj)
}
func (*binaryClassFramebufferAttachmentInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFramebufferAttachmentInfo(d, obj.(*FramebufferAttachmentInfo))
}
func (*binaryClassFramebufferAttachmentInfo) Skip(d binary.Decoder) error {
	return doSkipFramebufferAttachmentInfo(d)
}
func (*binaryClassFramebufferAttachmentInfo) Schema() *schema.Class {
	return schemaFramebufferAttachmentInfo
}

var schemaFramebufferAttachmentInfo = &schema.Class{
	TypeID:  binaryIDFramebufferAttachmentInfo,
	Package: "gles",
	Name:    "FramebufferAttachmentInfo",
	Fields: []schema.Field{
		{Declared: "Object", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TextureLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "CubeMapFace", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassFramebuffer struct{}

func (*Framebuffer) Class() binary.Class {
	return (*binaryClassFramebuffer)(nil)
}
func doEncodeFramebuffer(e binary.Encoder, o *Framebuffer) error {
	if err := e.Uint32(uint32(len(o.Attachments))); err != nil {
		return err
	}
	for k, v := range o.Attachments {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeFramebuffer(d binary.Decoder, o *Framebuffer) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachments = make(GLenumːFramebufferAttachmentInfoᵐ, count)
		m := o.Attachments
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferAttachmentInfo
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	return nil
}
func doSkipFramebuffer(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if err := d.SkipValue((*FramebufferAttachmentInfo)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassFramebuffer) ID() binary.ID      { return binaryIDFramebuffer }
func (*binaryClassFramebuffer) New() binary.Object { return &Framebuffer{} }
func (*binaryClassFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFramebuffer(e, obj.(*Framebuffer))
}
func (*binaryClassFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Framebuffer{}
	return obj, doDecodeFramebuffer(d, obj)
}
func (*binaryClassFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFramebuffer(d, obj.(*Framebuffer))
}
func (*binaryClassFramebuffer) Skip(d binary.Decoder) error { return doSkipFramebuffer(d) }
func (*binaryClassFramebuffer) Schema() *schema.Class       { return schemaFramebuffer }

var schemaFramebuffer = &schema.Class{
	TypeID:  binaryIDFramebuffer,
	Package: "gles",
	Name:    "Framebuffer",
	Fields: []schema.Field{
		{Declared: "Attachments", Type: &schema.Map{Alias: "GLenumːFramebufferAttachmentInfoᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Struct{Name: "FramebufferAttachmentInfo", ID: (*FramebufferAttachmentInfo)(nil).Class().ID()}}},
	},
}

type binaryClassGLcharˢ struct{}

func (*GLcharˢ) Class() binary.Class {
	return (*binaryClassGLcharˢ)(nil)
}
func doEncodeGLcharˢ(e binary.Encoder, o *GLcharˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharˢ(d binary.Decoder, o *GLcharˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharˢ) ID() binary.ID      { return binaryIDGLcharˢ }
func (*binaryClassGLcharˢ) New() binary.Object { return &GLcharˢ{} }
func (*binaryClassGLcharˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharˢ(e, obj.(*GLcharˢ))
}
func (*binaryClassGLcharˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharˢ{}
	return obj, doDecodeGLcharˢ(d, obj)
}
func (*binaryClassGLcharˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharˢ(d, obj.(*GLcharˢ))
}
func (*binaryClassGLcharˢ) Skip(d binary.Decoder) error { return doSkipGLcharˢ(d) }
func (*binaryClassGLcharˢ) Schema() *schema.Class       { return schemaGLcharˢ }

var schemaGLcharˢ = &schema.Class{
	TypeID:  binaryIDGLcharˢ,
	Package: "gles",
	Name:    "GLcharˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassShader struct{}

func (*Shader) Class() binary.Class {
	return (*binaryClassShader)(nil)
}
func doEncodeShader(e binary.Encoder, o *Shader) error {
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	if err := e.Bool(o.Compiled); err != nil {
		return err
	}
	if err := e.Bool(o.Deletable); err != nil {
		return err
	}
	if err := e.Value(&o.InfoLog); err != nil {
		return err
	}
	if err := e.String(o.Source); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	return nil
}
func doDecodeShader(d binary.Decoder, o *Shader) error {
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Compiled = bool(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Deletable = bool(obj)
	}
	if err := d.Value(&o.InfoLog); err != nil {
		return err
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Source = string(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	return nil
}
func doSkipShader(d binary.Decoder) error {
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassShader) ID() binary.ID      { return binaryIDShader }
func (*binaryClassShader) New() binary.Object { return &Shader{} }
func (*binaryClassShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeShader(e, obj.(*Shader))
}
func (*binaryClassShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Shader{}
	return obj, doDecodeShader(d, obj)
}
func (*binaryClassShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeShader(d, obj.(*Shader))
}
func (*binaryClassShader) Skip(d binary.Decoder) error { return doSkipShader(d) }
func (*binaryClassShader) Schema() *schema.Class       { return schemaShader }

var schemaShader = &schema.Class{
	TypeID:  binaryIDShader,
	Package: "gles",
	Name:    "Shader",
	Fields: []schema.Field{
		{Declared: "Binary", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "Compiled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "Deletable", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "InfoLog", Type: &schema.Struct{Name: "GLcharˢ", ID: (*GLcharˢ)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassVertexAttribute struct{}

func (*VertexAttribute) Class() binary.Class {
	return (*binaryClassVertexAttribute)(nil)
}
func doEncodeVertexAttribute(e binary.Encoder, o *VertexAttribute) error {
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	if err := e.Int32(o.VectorCount); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexAttribute(d binary.Decoder, o *VertexAttribute) error {
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.VectorCount = int32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	return nil
}
func doSkipVertexAttribute(d binary.Decoder) error {
	if err := d.SkipValue((*Charˢ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexAttribute) ID() binary.ID      { return binaryIDVertexAttribute }
func (*binaryClassVertexAttribute) New() binary.Object { return &VertexAttribute{} }
func (*binaryClassVertexAttribute) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexAttribute(e, obj.(*VertexAttribute))
}
func (*binaryClassVertexAttribute) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexAttribute{}
	return obj, doDecodeVertexAttribute(d, obj)
}
func (*binaryClassVertexAttribute) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexAttribute(d, obj.(*VertexAttribute))
}
func (*binaryClassVertexAttribute) Skip(d binary.Decoder) error { return doSkipVertexAttribute(d) }
func (*binaryClassVertexAttribute) Schema() *schema.Class       { return schemaVertexAttribute }

var schemaVertexAttribute = &schema.Class{
	TypeID:  binaryIDVertexAttribute,
	Package: "gles",
	Name:    "VertexAttribute",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Struct{Name: "Charˢ", ID: (*Charˢ)(nil).Class().ID()}},
		{Declared: "VectorCount", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassUniform struct{}

func (*Uniform) Class() binary.Class {
	return (*binaryClassUniform)(nil)
}
func doEncodeUniform(e binary.Encoder, o *Uniform) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeUniform(d binary.Decoder, o *Uniform) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipUniform(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassUniform) ID() binary.ID      { return binaryIDUniform }
func (*binaryClassUniform) New() binary.Object { return &Uniform{} }
func (*binaryClassUniform) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeUniform(e, obj.(*Uniform))
}
func (*binaryClassUniform) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Uniform{}
	return obj, doDecodeUniform(d, obj)
}
func (*binaryClassUniform) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeUniform(d, obj.(*Uniform))
}
func (*binaryClassUniform) Skip(d binary.Decoder) error { return doSkipUniform(d) }
func (*binaryClassUniform) Schema() *schema.Class       { return schemaUniform }

var schemaUniform = &schema.Class{
	TypeID:  binaryIDUniform,
	Package: "gles",
	Name:    "Uniform",
	Fields: []schema.Field{
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
	},
}

type binaryClassProgram struct{}

func (*Program) Class() binary.Class {
	return (*binaryClassProgram)(nil)
}
func doEncodeProgram(e binary.Encoder, o *Program) error {
	if err := e.Uint32(uint32(len(o.Shaders))); err != nil {
		return err
	}
	for k, v := range o.Shaders {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Bool(o.Linked); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.AttributeBindings))); err != nil {
		return err
	}
	for k, v := range o.AttributeBindings {
		if err := e.String(k); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Attributes))); err != nil {
		return err
	}
	for k, v := range o.Attributes {
		if err := e.Int32(k); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Uniforms))); err != nil {
		return err
	}
	for k, v := range o.Uniforms {
		if err := e.Int32(int32(k)); err != nil {
			return err
		}
		if err := e.Value(&v); err != nil {
			return err
		}
	}
	if err := e.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doDecodeProgram(d binary.Decoder, o *Program) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shaders = make(GLenumːShaderIdᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v ShaderId
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = ShaderId(obj)
			}
			m[k] = v
		}
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Linked = bool(obj)
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.AttributeBindings = make(StringːAttributeLocationᵐ, count)
		m := o.AttributeBindings
		for i := uint32(0); i < count; i++ {
			var k string
			var v AttributeLocation
			if obj, err := d.String(); err != nil {
				return err
			} else {
				k = string(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = AttributeLocation(obj)
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attributes = make(S32ːVertexAttributeᵐ, count)
		m := o.Attributes
		for i := uint32(0); i < count; i++ {
			var k int32
			var v VertexAttribute
			if obj, err := d.Int32(); err != nil {
				return err
			} else {
				k = int32(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Uniforms = make(UniformLocationːUniformᵐ, count)
		m := o.Uniforms
		for i := uint32(0); i < count; i++ {
			var k UniformLocation
			var v Uniform
			if obj, err := d.Int32(); err != nil {
				return err
			} else {
				k = UniformLocation(obj)
			}
			if err := d.Value(&v); err != nil {
				return err
			}
			m[k] = v
		}
	}
	if err := d.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doSkipProgram(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipString(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Int32(); err != nil {
				return err
			}
			if err := d.SkipValue((*VertexAttribute)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Int32(); err != nil {
				return err
			}
			if err := d.SkipValue((*Uniform)(nil)); err != nil {
				return err
			}
		}
	}
	if err := d.SkipValue((*GLcharˢ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassProgram) ID() binary.ID      { return binaryIDProgram }
func (*binaryClassProgram) New() binary.Object { return &Program{} }
func (*binaryClassProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeProgram(e, obj.(*Program))
}
func (*binaryClassProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Program{}
	return obj, doDecodeProgram(d, obj)
}
func (*binaryClassProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeProgram(d, obj.(*Program))
}
func (*binaryClassProgram) Skip(d binary.Decoder) error { return doSkipProgram(d) }
func (*binaryClassProgram) Schema() *schema.Class       { return schemaProgram }

var schemaProgram = &schema.Class{
	TypeID:  binaryIDProgram,
	Package: "gles",
	Name:    "Program",
	Fields: []schema.Field{
		{Declared: "Shaders", Type: &schema.Map{Alias: "GLenumːShaderIdᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}}},
		{Declared: "Linked", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "Binary", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "AttributeBindings", Type: &schema.Map{Alias: "StringːAttributeLocationᵐ", KeyType: &schema.Primitive{Name: "string", Method: schema.String}, ValueType: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}}},
		{Declared: "Attributes", Type: &schema.Map{Alias: "S32ːVertexAttributeᵐ", KeyType: &schema.Primitive{Name: "int32", Method: schema.Int32}, ValueType: &schema.Struct{Name: "VertexAttribute", ID: (*VertexAttribute)(nil).Class().ID()}}},
		{Declared: "Uniforms", Type: &schema.Map{Alias: "UniformLocationːUniformᵐ", KeyType: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}, ValueType: &schema.Struct{Name: "Uniform", ID: (*Uniform)(nil).Class().ID()}}},
		{Declared: "InfoLog", Type: &schema.Struct{Name: "GLcharˢ", ID: (*GLcharˢ)(nil).Class().ID()}},
	},
}

type binaryClassVertexArray struct{}

func (*VertexArray) Class() binary.Class {
	return (*binaryClassVertexArray)(nil)
}
func doEncodeVertexArray(e binary.Encoder, o *VertexArray) error {
	return nil
}
func doDecodeVertexArray(d binary.Decoder, o *VertexArray) error {
	return nil
}
func doSkipVertexArray(d binary.Decoder) error {
	return nil
}
func (*binaryClassVertexArray) ID() binary.ID      { return binaryIDVertexArray }
func (*binaryClassVertexArray) New() binary.Object { return &VertexArray{} }
func (*binaryClassVertexArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexArray(e, obj.(*VertexArray))
}
func (*binaryClassVertexArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexArray{}
	return obj, doDecodeVertexArray(d, obj)
}
func (*binaryClassVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexArray(d, obj.(*VertexArray))
}
func (*binaryClassVertexArray) Skip(d binary.Decoder) error { return doSkipVertexArray(d) }
func (*binaryClassVertexArray) Schema() *schema.Class       { return schemaVertexArray }

var schemaVertexArray = &schema.Class{
	TypeID:  binaryIDVertexArray,
	Package: "gles",
	Name:    "VertexArray",
	Fields:  []schema.Field{},
}

type binaryClassQuery struct{}

func (*Query) Class() binary.Class {
	return (*binaryClassQuery)(nil)
}
func doEncodeQuery(e binary.Encoder, o *Query) error {
	return nil
}
func doDecodeQuery(d binary.Decoder, o *Query) error {
	return nil
}
func doSkipQuery(d binary.Decoder) error {
	return nil
}
func (*binaryClassQuery) ID() binary.ID      { return binaryIDQuery }
func (*binaryClassQuery) New() binary.Object { return &Query{} }
func (*binaryClassQuery) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeQuery(e, obj.(*Query))
}
func (*binaryClassQuery) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Query{}
	return obj, doDecodeQuery(d, obj)
}
func (*binaryClassQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeQuery(d, obj.(*Query))
}
func (*binaryClassQuery) Skip(d binary.Decoder) error { return doSkipQuery(d) }
func (*binaryClassQuery) Schema() *schema.Class       { return schemaQuery }

var schemaQuery = &schema.Class{
	TypeID:  binaryIDQuery,
	Package: "gles",
	Name:    "Query",
	Fields:  []schema.Field{},
}

type binaryClassObjects struct{}

func (*Objects) Class() binary.Class {
	return (*binaryClassObjects)(nil)
}
func doEncodeObjects(e binary.Encoder, o *Objects) error {
	if err := e.Uint32(uint32(len(o.Renderbuffers))); err != nil {
		return err
	}
	for k, v := range o.Renderbuffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Textures))); err != nil {
		return err
	}
	for k, v := range o.Textures {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Framebuffers))); err != nil {
		return err
	}
	for k, v := range o.Framebuffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Buffers))); err != nil {
		return err
	}
	for k, v := range o.Buffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Shaders))); err != nil {
		return err
	}
	for k, v := range o.Shaders {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Programs))); err != nil {
		return err
	}
	for k, v := range o.Programs {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.VertexArrays))); err != nil {
		return err
	}
	for k, v := range o.VertexArrays {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Queries))); err != nil {
		return err
	}
	for k, v := range o.Queries {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeObjects(d binary.Decoder, o *Objects) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Renderbuffers = make(RenderbufferIdːRenderbufferʳᵐ, count)
		m := o.Renderbuffers
		for i := uint32(0); i < count; i++ {
			var k RenderbufferId
			var v *Renderbuffer
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = RenderbufferId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Renderbuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Textures = make(TextureIdːTextureʳᵐ, count)
		m := o.Textures
		for i := uint32(0); i < count; i++ {
			var k TextureId
			var v *Texture
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = TextureId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Texture)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Framebuffers = make(FramebufferIdːFramebufferʳᵐ, count)
		m := o.Framebuffers
		for i := uint32(0); i < count; i++ {
			var k FramebufferId
			var v *Framebuffer
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = FramebufferId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Framebuffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffers = make(BufferIdːBufferʳᵐ, count)
		m := o.Buffers
		for i := uint32(0); i < count; i++ {
			var k BufferId
			var v *Buffer
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = BufferId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Buffer)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shaders = make(ShaderIdːShaderʳᵐ, count)
		m := o.Shaders
		for i := uint32(0); i < count; i++ {
			var k ShaderId
			var v *Shader
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = ShaderId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Shader)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Programs = make(ProgramIdːProgramʳᵐ, count)
		m := o.Programs
		for i := uint32(0); i < count; i++ {
			var k ProgramId
			var v *Program
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = ProgramId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Program)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.VertexArrays = make(VertexArrayIdːVertexArrayʳᵐ, count)
		m := o.VertexArrays
		for i := uint32(0); i < count; i++ {
			var k VertexArrayId
			var v *VertexArray
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = VertexArrayId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*VertexArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Queries = make(QueryIdːQueryʳᵐ, count)
		m := o.Queries
		for i := uint32(0); i < count; i++ {
			var k QueryId
			var v *Query
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = QueryId(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Query)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	return nil
}
func doSkipObjects(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassObjects) ID() binary.ID      { return binaryIDObjects }
func (*binaryClassObjects) New() binary.Object { return &Objects{} }
func (*binaryClassObjects) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeObjects(e, obj.(*Objects))
}
func (*binaryClassObjects) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Objects{}
	return obj, doDecodeObjects(d, obj)
}
func (*binaryClassObjects) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeObjects(d, obj.(*Objects))
}
func (*binaryClassObjects) Skip(d binary.Decoder) error { return doSkipObjects(d) }
func (*binaryClassObjects) Schema() *schema.Class       { return schemaObjects }

var schemaObjects = &schema.Class{
	TypeID:  binaryIDObjects,
	Package: "gles",
	Name:    "Objects",
	Fields: []schema.Field{
		{Declared: "Renderbuffers", Type: &schema.Map{Alias: "RenderbufferIdːRenderbufferʳᵐ", KeyType: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Renderbuffer", ID: (*Renderbuffer)(nil).Class().ID()}}}},
		{Declared: "Textures", Type: &schema.Map{Alias: "TextureIdːTextureʳᵐ", KeyType: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Texture", ID: (*Texture)(nil).Class().ID()}}}},
		{Declared: "Framebuffers", Type: &schema.Map{Alias: "FramebufferIdːFramebufferʳᵐ", KeyType: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Framebuffer", ID: (*Framebuffer)(nil).Class().ID()}}}},
		{Declared: "Buffers", Type: &schema.Map{Alias: "BufferIdːBufferʳᵐ", KeyType: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Buffer", ID: (*Buffer)(nil).Class().ID()}}}},
		{Declared: "Shaders", Type: &schema.Map{Alias: "ShaderIdːShaderʳᵐ", KeyType: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Shader", ID: (*Shader)(nil).Class().ID()}}}},
		{Declared: "Programs", Type: &schema.Map{Alias: "ProgramIdːProgramʳᵐ", KeyType: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Program", ID: (*Program)(nil).Class().ID()}}}},
		{Declared: "VertexArrays", Type: &schema.Map{Alias: "VertexArrayIdːVertexArrayʳᵐ", KeyType: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "VertexArray", ID: (*VertexArray)(nil).Class().ID()}}}},
		{Declared: "Queries", Type: &schema.Map{Alias: "QueryIdːQueryʳᵐ", KeyType: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Query", ID: (*Query)(nil).Class().ID()}}}},
	},
}

type binaryClassContext struct{}

func (*Context) Class() binary.Class {
	return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Encoder, o *Context) error {
	if err := e.Uint32(uint32(o.Identifier)); err != nil {
		return err
	}
	if err := e.Value(&o.Blending); err != nil {
		return err
	}
	if err := e.Value(&o.Rasterizing); err != nil {
		return err
	}
	if err := e.Value(&o.Clearing); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.BoundFramebuffers))); err != nil {
		return err
	}
	for k, v := range o.BoundFramebuffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.BoundRenderbuffers))); err != nil {
		return err
	}
	for k, v := range o.BoundRenderbuffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.BoundBuffers))); err != nil {
		return err
	}
	for k, v := range o.BoundBuffers {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(v)); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(o.BoundProgram)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BoundVertexArray)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.VertexAttributeArrays))); err != nil {
		return err
	}
	for k, v := range o.VertexAttributeArrays {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.TextureUnits))); err != nil {
		return err
	}
	for k, v := range o.TextureUnits {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Uint32(uint32(len(v))); err != nil {
			return err
		}
		for k, v := range v {
			if err := e.Uint32(uint32(k)); err != nil {
				return err
			}
			if err := e.Uint32(uint32(v)); err != nil {
				return err
			}
		}
	}
	if err := e.Uint32(uint32(o.ActiveTextureUnit)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Capabilities))); err != nil {
		return err
	}
	for k, v := range o.Capabilities {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Bool(v); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(o.GenerateMipmapHint)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.PixelStorage))); err != nil {
		return err
	}
	for k, v := range o.PixelStorage {
		if err := e.Uint32(uint32(k)); err != nil {
			return err
		}
		if err := e.Int32(int32(v)); err != nil {
			return err
		}
	}
	if err := e.Value(&o.Instances); err != nil {
		return err
	}
	if err := e.Bool(o.PreserveBuffersOnSwap); err != nil {
		return err
	}
	return nil
}
func doDecodeContext(d binary.Decoder, o *Context) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Identifier = ContextID(obj)
	}
	if err := d.Value(&o.Blending); err != nil {
		return err
	}
	if err := d.Value(&o.Rasterizing); err != nil {
		return err
	}
	if err := d.Value(&o.Clearing); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BoundFramebuffers = make(GLenumːFramebufferIdᵐ, count)
		m := o.BoundFramebuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v FramebufferId
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = FramebufferId(obj)
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BoundRenderbuffers = make(GLenumːRenderbufferIdᵐ, count)
		m := o.BoundRenderbuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v RenderbufferId
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = RenderbufferId(obj)
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BoundBuffers = make(GLenumːBufferIdᵐ, count)
		m := o.BoundBuffers
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v BufferId
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				v = BufferId(obj)
			}
			m[k] = v
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BoundProgram = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BoundVertexArray = VertexArrayId(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.VertexAttributeArrays = make(AttributeLocationːVertexAttributeArrayʳᵐ, count)
		m := o.VertexAttributeArrays
		for i := uint32(0); i < count; i++ {
			var k AttributeLocation
			var v *VertexAttributeArray
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = AttributeLocation(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*VertexAttributeArray)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TextureUnits = make(GLenumːGLenumːTextureIdᵐᵐ, count)
		m := o.TextureUnits
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v GLenumːTextureIdᵐ
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if count, err := d.Uint32(); err != nil {
				return err
			} else {
				v = make(GLenumːTextureIdᵐ, count)
				m := v
				for i := uint32(0); i < count; i++ {
					var k GLenum
					var v TextureId
					if obj, err := d.Uint32(); err != nil {
						return err
					} else {
						k = GLenum(obj)
					}
					if obj, err := d.Uint32(); err != nil {
						return err
					} else {
						v = TextureId(obj)
					}
					m[k] = v
				}
			}
			m[k] = v
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ActiveTextureUnit = GLenum(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Capabilities = make(GLenumːboolᵐ, count)
		m := o.Capabilities
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v bool
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Bool(); err != nil {
				return err
			} else {
				v = bool(obj)
			}
			m[k] = v
		}
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.GenerateMipmapHint = GLenum(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PixelStorage = make(GLenumːGLintᵐ, count)
		m := o.PixelStorage
		for i := uint32(0); i < count; i++ {
			var k GLenum
			var v GLint
			if obj, err := d.Uint32(); err != nil {
				return err
			} else {
				k = GLenum(obj)
			}
			if obj, err := d.Int32(); err != nil {
				return err
			} else {
				v = GLint(obj)
			}
			m[k] = v
		}
	}
	if err := d.Value(&o.Instances); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.PreserveBuffersOnSwap = bool(obj)
	}
	return nil
}
func doSkipContext(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BlendState)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*RasterizerState)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ClearState)(nil)); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Uint32(); err != nil {
				return err
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if count, err := d.Uint32(); err != nil {
				return err
			} else {
				for i := uint32(0); i < count; i++ {
					if _, err := d.Uint32(); err != nil {
						return err
					}
					if _, err := d.Uint32(); err != nil {
						return err
					}
				}
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Bool(); err != nil {
				return err
			}
		}
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint32(); err != nil {
				return err
			}
			if _, err := d.Int32(); err != nil {
				return err
			}
		}
	}
	if err := d.SkipValue((*Objects)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassContext) ID() binary.ID      { return binaryIDContext }
func (*binaryClassContext) New() binary.Object { return &Context{} }
func (*binaryClassContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeContext(e, obj.(*Context))
}
func (*binaryClassContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Context{}
	return obj, doDecodeContext(d, obj)
}
func (*binaryClassContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeContext(d, obj.(*Context))
}
func (*binaryClassContext) Skip(d binary.Decoder) error { return doSkipContext(d) }
func (*binaryClassContext) Schema() *schema.Class       { return schemaContext }

var schemaContext = &schema.Class{
	TypeID:  binaryIDContext,
	Package: "gles",
	Name:    "Context",
	Fields: []schema.Field{
		{Declared: "Identifier", Type: &schema.Primitive{Name: "ContextID", Method: schema.Uint32}},
		{Declared: "Blending", Type: &schema.Struct{Name: "BlendState", ID: (*BlendState)(nil).Class().ID()}},
		{Declared: "Rasterizing", Type: &schema.Struct{Name: "RasterizerState", ID: (*RasterizerState)(nil).Class().ID()}},
		{Declared: "Clearing", Type: &schema.Struct{Name: "ClearState", ID: (*ClearState)(nil).Class().ID()}},
		{Declared: "BoundFramebuffers", Type: &schema.Map{Alias: "GLenumːFramebufferIdᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}}},
		{Declared: "BoundRenderbuffers", Type: &schema.Map{Alias: "GLenumːRenderbufferIdᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}}},
		{Declared: "BoundBuffers", Type: &schema.Map{Alias: "GLenumːBufferIdᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}}},
		{Declared: "BoundProgram", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BoundVertexArray", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
		{Declared: "VertexAttributeArrays", Type: &schema.Map{Alias: "AttributeLocationːVertexAttributeArrayʳᵐ", KeyType: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "VertexAttributeArray", ID: (*VertexAttributeArray)(nil).Class().ID()}}}},
		{Declared: "TextureUnits", Type: &schema.Map{Alias: "GLenumːGLenumːTextureIdᵐᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Map{Alias: "GLenumːTextureIdᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}}}},
		{Declared: "ActiveTextureUnit", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Capabilities", Type: &schema.Map{Alias: "GLenumːboolᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "bool", Method: schema.Bool}}},
		{Declared: "GenerateMipmapHint", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "PixelStorage", Type: &schema.Map{Alias: "GLenumːGLintᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}}},
		{Declared: "Instances", Type: &schema.Struct{Name: "Objects", ID: (*Objects)(nil).Class().ID()}},
		{Declared: "PreserveBuffersOnSwap", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassEGLConfig struct{}

func (*EGLConfig) Class() binary.Class {
	return (*binaryClassEGLConfig)(nil)
}
func doEncodeEGLConfig(e binary.Encoder, o *EGLConfig) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLConfig(d binary.Decoder, o *EGLConfig) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipEGLConfig(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLConfig) ID() binary.ID      { return binaryIDEGLConfig }
func (*binaryClassEGLConfig) New() binary.Object { return &EGLConfig{} }
func (*binaryClassEGLConfig) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLConfig(e, obj.(*EGLConfig))
}
func (*binaryClassEGLConfig) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLConfig{}
	return obj, doDecodeEGLConfig(d, obj)
}
func (*binaryClassEGLConfig) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLConfig(d, obj.(*EGLConfig))
}
func (*binaryClassEGLConfig) Skip(d binary.Decoder) error { return doSkipEGLConfig(d) }
func (*binaryClassEGLConfig) Schema() *schema.Class       { return schemaEGLConfig }

var schemaEGLConfig = &schema.Class{
	TypeID:  binaryIDEGLConfig,
	Package: "gles",
	Name:    "EGLConfig",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEGLContext struct{}

func (*EGLContext) Class() binary.Class {
	return (*binaryClassEGLContext)(nil)
}
func doEncodeEGLContext(e binary.Encoder, o *EGLContext) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLContext(d binary.Decoder, o *EGLContext) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipEGLContext(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLContext) ID() binary.ID      { return binaryIDEGLContext }
func (*binaryClassEGLContext) New() binary.Object { return &EGLContext{} }
func (*binaryClassEGLContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLContext(e, obj.(*EGLContext))
}
func (*binaryClassEGLContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLContext{}
	return obj, doDecodeEGLContext(d, obj)
}
func (*binaryClassEGLContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLContext(d, obj.(*EGLContext))
}
func (*binaryClassEGLContext) Skip(d binary.Decoder) error { return doSkipEGLContext(d) }
func (*binaryClassEGLContext) Schema() *schema.Class       { return schemaEGLContext }

var schemaEGLContext = &schema.Class{
	TypeID:  binaryIDEGLContext,
	Package: "gles",
	Name:    "EGLContext",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEGLDisplay struct{}

func (*EGLDisplay) Class() binary.Class {
	return (*binaryClassEGLDisplay)(nil)
}
func doEncodeEGLDisplay(e binary.Encoder, o *EGLDisplay) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLDisplay(d binary.Decoder, o *EGLDisplay) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipEGLDisplay(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLDisplay) ID() binary.ID      { return binaryIDEGLDisplay }
func (*binaryClassEGLDisplay) New() binary.Object { return &EGLDisplay{} }
func (*binaryClassEGLDisplay) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLDisplay(e, obj.(*EGLDisplay))
}
func (*binaryClassEGLDisplay) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLDisplay{}
	return obj, doDecodeEGLDisplay(d, obj)
}
func (*binaryClassEGLDisplay) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLDisplay(d, obj.(*EGLDisplay))
}
func (*binaryClassEGLDisplay) Skip(d binary.Decoder) error { return doSkipEGLDisplay(d) }
func (*binaryClassEGLDisplay) Schema() *schema.Class       { return schemaEGLDisplay }

var schemaEGLDisplay = &schema.Class{
	TypeID:  binaryIDEGLDisplay,
	Package: "gles",
	Name:    "EGLDisplay",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEGLSurface struct{}

func (*EGLSurface) Class() binary.Class {
	return (*binaryClassEGLSurface)(nil)
}
func doEncodeEGLSurface(e binary.Encoder, o *EGLSurface) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLSurface(d binary.Decoder, o *EGLSurface) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipEGLSurface(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLSurface) ID() binary.ID      { return binaryIDEGLSurface }
func (*binaryClassEGLSurface) New() binary.Object { return &EGLSurface{} }
func (*binaryClassEGLSurface) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLSurface(e, obj.(*EGLSurface))
}
func (*binaryClassEGLSurface) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLSurface{}
	return obj, doDecodeEGLSurface(d, obj)
}
func (*binaryClassEGLSurface) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLSurface(d, obj.(*EGLSurface))
}
func (*binaryClassEGLSurface) Skip(d binary.Decoder) error { return doSkipEGLSurface(d) }
func (*binaryClassEGLSurface) Schema() *schema.Class       { return schemaEGLSurface }

var schemaEGLSurface = &schema.Class{
	TypeID:  binaryIDEGLSurface,
	Package: "gles",
	Name:    "EGLSurface",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEGLintˢ struct{}

func (*EGLintˢ) Class() binary.Class {
	return (*binaryClassEGLintˢ)(nil)
}
func doEncodeEGLintˢ(e binary.Encoder, o *EGLintˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLintˢ(d binary.Decoder, o *EGLintˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipEGLintˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLintˢ) ID() binary.ID      { return binaryIDEGLintˢ }
func (*binaryClassEGLintˢ) New() binary.Object { return &EGLintˢ{} }
func (*binaryClassEGLintˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLintˢ(e, obj.(*EGLintˢ))
}
func (*binaryClassEGLintˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLintˢ{}
	return obj, doDecodeEGLintˢ(d, obj)
}
func (*binaryClassEGLintˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLintˢ(d, obj.(*EGLintˢ))
}
func (*binaryClassEGLintˢ) Skip(d binary.Decoder) error { return doSkipEGLintˢ(d) }
func (*binaryClassEGLintˢ) Schema() *schema.Class       { return schemaEGLintˢ }

var schemaEGLintˢ = &schema.Class{
	TypeID:  binaryIDEGLintˢ,
	Package: "gles",
	Name:    "EGLintˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassEGLintᵖ struct{}

func (*EGLintᵖ) Class() binary.Class {
	return (*binaryClassEGLintᵖ)(nil)
}
func doEncodeEGLintᵖ(e binary.Encoder, o *EGLintᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeEGLintᵖ(d binary.Decoder, o *EGLintᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipEGLintᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEGLintᵖ) ID() binary.ID      { return binaryIDEGLintᵖ }
func (*binaryClassEGLintᵖ) New() binary.Object { return &EGLintᵖ{} }
func (*binaryClassEGLintᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEGLintᵖ(e, obj.(*EGLintᵖ))
}
func (*binaryClassEGLintᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EGLintᵖ{}
	return obj, doDecodeEGLintᵖ(d, obj)
}
func (*binaryClassEGLintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEGLintᵖ(d, obj.(*EGLintᵖ))
}
func (*binaryClassEGLintᵖ) Skip(d binary.Decoder) error { return doSkipEGLintᵖ(d) }
func (*binaryClassEGLintᵖ) Schema() *schema.Class       { return schemaEGLintᵖ }

var schemaEGLintᵖ = &schema.Class{
	TypeID:  binaryIDEGLintᵖ,
	Package: "gles",
	Name:    "EGLintᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEglCreateContext struct{}

func (*EglCreateContext) Class() binary.Class {
	return (*binaryClassEglCreateContext)(nil)
}
func doEncodeEglCreateContext(e binary.Encoder, o *EglCreateContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Config); err != nil {
		return err
	}
	if err := e.Value(&o.ShareContext); err != nil {
		return err
	}
	if err := e.Value(&o.AttribList); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeEglCreateContext(d binary.Decoder, o *EglCreateContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Config); err != nil {
		return err
	}
	if err := d.Value(&o.ShareContext); err != nil {
		return err
	}
	if err := d.Value(&o.AttribList); err != nil {
		return err
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipEglCreateContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLConfig)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLContext)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLContext)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEglCreateContext) ID() binary.ID      { return binaryIDEglCreateContext }
func (*binaryClassEglCreateContext) New() binary.Object { return &EglCreateContext{} }
func (*binaryClassEglCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEglCreateContext(e, obj.(*EglCreateContext))
}
func (*binaryClassEglCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EglCreateContext{}
	return obj, doDecodeEglCreateContext(d, obj)
}
func (*binaryClassEglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEglCreateContext(d, obj.(*EglCreateContext))
}
func (*binaryClassEglCreateContext) Skip(d binary.Decoder) error { return doSkipEglCreateContext(d) }
func (*binaryClassEglCreateContext) Schema() *schema.Class       { return schemaEglCreateContext }

var schemaEglCreateContext = &schema.Class{
	TypeID:  binaryIDEglCreateContext,
	Package: "gles",
	Name:    "EglCreateContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay", ID: (*EGLDisplay)(nil).Class().ID()}},
		{Declared: "Config", Type: &schema.Struct{Name: "EGLConfig", ID: (*EGLConfig)(nil).Class().ID()}},
		{Declared: "ShareContext", Type: &schema.Struct{Name: "EGLContext", ID: (*EGLContext)(nil).Class().ID()}},
		{Declared: "AttribList", Type: &schema.Struct{Name: "EGLintᵖ", ID: (*EGLintᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Struct{Name: "EGLContext", ID: (*EGLContext)(nil).Class().ID()}},
	},
}

type binaryClassEglInitialize struct{}

func (*EglInitialize) Class() binary.Class {
	return (*binaryClassEglInitialize)(nil)
}
func doEncodeEglInitialize(e binary.Encoder, o *EglInitialize) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Dpy); err != nil {
		return err
	}
	if err := e.Value(&o.Major); err != nil {
		return err
	}
	if err := e.Value(&o.Minor); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeEglInitialize(d binary.Decoder, o *EglInitialize) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Dpy); err != nil {
		return err
	}
	if err := d.Value(&o.Major); err != nil {
		return err
	}
	if err := d.Value(&o.Minor); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = EGLBoolean(obj)
	}
	return nil
}
func doSkipEglInitialize(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEglInitialize) ID() binary.ID      { return binaryIDEglInitialize }
func (*binaryClassEglInitialize) New() binary.Object { return &EglInitialize{} }
func (*binaryClassEglInitialize) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEglInitialize(e, obj.(*EglInitialize))
}
func (*binaryClassEglInitialize) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EglInitialize{}
	return obj, doDecodeEglInitialize(d, obj)
}
func (*binaryClassEglInitialize) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEglInitialize(d, obj.(*EglInitialize))
}
func (*binaryClassEglInitialize) Skip(d binary.Decoder) error { return doSkipEglInitialize(d) }
func (*binaryClassEglInitialize) Schema() *schema.Class       { return schemaEglInitialize }

var schemaEglInitialize = &schema.Class{
	TypeID:  binaryIDEglInitialize,
	Package: "gles",
	Name:    "EglInitialize",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Dpy", Type: &schema.Struct{Name: "EGLDisplay", ID: (*EGLDisplay)(nil).Class().ID()}},
		{Declared: "Major", Type: &schema.Struct{Name: "EGLintᵖ", ID: (*EGLintᵖ)(nil).Class().ID()}},
		{Declared: "Minor", Type: &schema.Struct{Name: "EGLintᵖ", ID: (*EGLintᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
	},
}

type binaryClassEglMakeCurrent struct{}

func (*EglMakeCurrent) Class() binary.Class {
	return (*binaryClassEglMakeCurrent)(nil)
}
func doEncodeEglMakeCurrent(e binary.Encoder, o *EglMakeCurrent) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Draw); err != nil {
		return err
	}
	if err := e.Value(&o.Read); err != nil {
		return err
	}
	if err := e.Value(&o.Context); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeEglMakeCurrent(d binary.Decoder, o *EglMakeCurrent) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Draw); err != nil {
		return err
	}
	if err := d.Value(&o.Read); err != nil {
		return err
	}
	if err := d.Value(&o.Context); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = EGLBoolean(obj)
	}
	return nil
}
func doSkipEglMakeCurrent(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLContext)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEglMakeCurrent) ID() binary.ID      { return binaryIDEglMakeCurrent }
func (*binaryClassEglMakeCurrent) New() binary.Object { return &EglMakeCurrent{} }
func (*binaryClassEglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEglMakeCurrent(e, obj.(*EglMakeCurrent))
}
func (*binaryClassEglMakeCurrent) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EglMakeCurrent{}
	return obj, doDecodeEglMakeCurrent(d, obj)
}
func (*binaryClassEglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEglMakeCurrent(d, obj.(*EglMakeCurrent))
}
func (*binaryClassEglMakeCurrent) Skip(d binary.Decoder) error { return doSkipEglMakeCurrent(d) }
func (*binaryClassEglMakeCurrent) Schema() *schema.Class       { return schemaEglMakeCurrent }

var schemaEglMakeCurrent = &schema.Class{
	TypeID:  binaryIDEglMakeCurrent,
	Package: "gles",
	Name:    "EglMakeCurrent",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay", ID: (*EGLDisplay)(nil).Class().ID()}},
		{Declared: "Draw", Type: &schema.Struct{Name: "EGLSurface", ID: (*EGLSurface)(nil).Class().ID()}},
		{Declared: "Read", Type: &schema.Struct{Name: "EGLSurface", ID: (*EGLSurface)(nil).Class().ID()}},
		{Declared: "Context", Type: &schema.Struct{Name: "EGLContext", ID: (*EGLContext)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
	},
}

type binaryClassEglQuerySurface struct{}

func (*EglQuerySurface) Class() binary.Class {
	return (*binaryClassEglQuerySurface)(nil)
}
func doEncodeEglQuerySurface(e binary.Encoder, o *EglQuerySurface) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Surface); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Attribute)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeEglQuerySurface(d binary.Decoder, o *EglQuerySurface) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Surface); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Attribute = EGLint(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = EGLBoolean(obj)
	}
	return nil
}
func doSkipEglQuerySurface(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLSurface)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLintᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEglQuerySurface) ID() binary.ID      { return binaryIDEglQuerySurface }
func (*binaryClassEglQuerySurface) New() binary.Object { return &EglQuerySurface{} }
func (*binaryClassEglQuerySurface) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEglQuerySurface(e, obj.(*EglQuerySurface))
}
func (*binaryClassEglQuerySurface) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EglQuerySurface{}
	return obj, doDecodeEglQuerySurface(d, obj)
}
func (*binaryClassEglQuerySurface) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEglQuerySurface(d, obj.(*EglQuerySurface))
}
func (*binaryClassEglQuerySurface) Skip(d binary.Decoder) error { return doSkipEglQuerySurface(d) }
func (*binaryClassEglQuerySurface) Schema() *schema.Class       { return schemaEglQuerySurface }

var schemaEglQuerySurface = &schema.Class{
	TypeID:  binaryIDEglQuerySurface,
	Package: "gles",
	Name:    "EglQuerySurface",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay", ID: (*EGLDisplay)(nil).Class().ID()}},
		{Declared: "Surface", Type: &schema.Struct{Name: "EGLSurface", ID: (*EGLSurface)(nil).Class().ID()}},
		{Declared: "Attribute", Type: &schema.Primitive{Name: "EGLint", Method: schema.Int64}},
		{Declared: "Value", Type: &schema.Struct{Name: "EGLintᵖ", ID: (*EGLintᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
	},
}

type binaryClassVoidᵖ struct{}

func (*Voidᵖ) Class() binary.Class {
	return (*binaryClassVoidᵖ)(nil)
}
func doEncodeVoidᵖ(e binary.Encoder, o *Voidᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᵖ(d binary.Decoder, o *Voidᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᵖ) ID() binary.ID      { return binaryIDVoidᵖ }
func (*binaryClassVoidᵖ) New() binary.Object { return &Voidᵖ{} }
func (*binaryClassVoidᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᵖ(e, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᵖ{}
	return obj, doDecodeVoidᵖ(d, obj)
}
func (*binaryClassVoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᵖ(d, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Skip(d binary.Decoder) error { return doSkipVoidᵖ(d) }
func (*binaryClassVoidᵖ) Schema() *schema.Class       { return schemaVoidᵖ }

var schemaVoidᵖ = &schema.Class{
	TypeID:  binaryIDVoidᵖ,
	Package: "gles",
	Name:    "Voidᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassEglSwapBuffers struct{}

func (*EglSwapBuffers) Class() binary.Class {
	return (*binaryClassEglSwapBuffers)(nil)
}
func doEncodeEglSwapBuffers(e binary.Encoder, o *EglSwapBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Surface); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeEglSwapBuffers(d binary.Decoder, o *EglSwapBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Surface); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = EGLBoolean(obj)
	}
	return nil
}
func doSkipEglSwapBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*EGLDisplay)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEglSwapBuffers) ID() binary.ID      { return binaryIDEglSwapBuffers }
func (*binaryClassEglSwapBuffers) New() binary.Object { return &EglSwapBuffers{} }
func (*binaryClassEglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEglSwapBuffers(e, obj.(*EglSwapBuffers))
}
func (*binaryClassEglSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EglSwapBuffers{}
	return obj, doDecodeEglSwapBuffers(d, obj)
}
func (*binaryClassEglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEglSwapBuffers(d, obj.(*EglSwapBuffers))
}
func (*binaryClassEglSwapBuffers) Skip(d binary.Decoder) error { return doSkipEglSwapBuffers(d) }
func (*binaryClassEglSwapBuffers) Schema() *schema.Class       { return schemaEglSwapBuffers }

var schemaEglSwapBuffers = &schema.Class{
	TypeID:  binaryIDEglSwapBuffers,
	Package: "gles",
	Name:    "EglSwapBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "EGLDisplay", ID: (*EGLDisplay)(nil).Class().ID()}},
		{Declared: "Surface", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "EGLBoolean", Method: schema.Int64}},
	},
}

type binaryClassF64ˢ struct{}

func (*F64ˢ) Class() binary.Class {
	return (*binaryClassF64ˢ)(nil)
}
func doEncodeF64ˢ(e binary.Encoder, o *F64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeF64ˢ(d binary.Decoder, o *F64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipF64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF64ˢ) ID() binary.ID      { return binaryIDF64ˢ }
func (*binaryClassF64ˢ) New() binary.Object { return &F64ˢ{} }
func (*binaryClassF64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF64ˢ(e, obj.(*F64ˢ))
}
func (*binaryClassF64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F64ˢ{}
	return obj, doDecodeF64ˢ(d, obj)
}
func (*binaryClassF64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF64ˢ(d, obj.(*F64ˢ))
}
func (*binaryClassF64ˢ) Skip(d binary.Decoder) error { return doSkipF64ˢ(d) }
func (*binaryClassF64ˢ) Schema() *schema.Class       { return schemaF64ˢ }

var schemaF64ˢ = &schema.Class{
	TypeID:  binaryIDF64ˢ,
	Package: "gles",
	Name:    "F64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassFlushPostBuffer struct{}

func (*FlushPostBuffer) Class() binary.Class {
	return (*binaryClassFlushPostBuffer)(nil)
}
func doEncodeFlushPostBuffer(e binary.Encoder, o *FlushPostBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeFlushPostBuffer(d binary.Decoder, o *FlushPostBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipFlushPostBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFlushPostBuffer) ID() binary.ID      { return binaryIDFlushPostBuffer }
func (*binaryClassFlushPostBuffer) New() binary.Object { return &FlushPostBuffer{} }
func (*binaryClassFlushPostBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFlushPostBuffer(e, obj.(*FlushPostBuffer))
}
func (*binaryClassFlushPostBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FlushPostBuffer{}
	return obj, doDecodeFlushPostBuffer(d, obj)
}
func (*binaryClassFlushPostBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFlushPostBuffer(d, obj.(*FlushPostBuffer))
}
func (*binaryClassFlushPostBuffer) Skip(d binary.Decoder) error { return doSkipFlushPostBuffer(d) }
func (*binaryClassFlushPostBuffer) Schema() *schema.Class       { return schemaFlushPostBuffer }

var schemaFlushPostBuffer = &schema.Class{
	TypeID:  binaryIDFlushPostBuffer,
	Package: "gles",
	Name:    "FlushPostBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassFramebufferIdˢ struct{}

func (*FramebufferIdˢ) Class() binary.Class {
	return (*binaryClassFramebufferIdˢ)(nil)
}
func doEncodeFramebufferIdˢ(e binary.Encoder, o *FramebufferIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeFramebufferIdˢ(d binary.Decoder, o *FramebufferIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipFramebufferIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFramebufferIdˢ) ID() binary.ID      { return binaryIDFramebufferIdˢ }
func (*binaryClassFramebufferIdˢ) New() binary.Object { return &FramebufferIdˢ{} }
func (*binaryClassFramebufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFramebufferIdˢ(e, obj.(*FramebufferIdˢ))
}
func (*binaryClassFramebufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FramebufferIdˢ{}
	return obj, doDecodeFramebufferIdˢ(d, obj)
}
func (*binaryClassFramebufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFramebufferIdˢ(d, obj.(*FramebufferIdˢ))
}
func (*binaryClassFramebufferIdˢ) Skip(d binary.Decoder) error { return doSkipFramebufferIdˢ(d) }
func (*binaryClassFramebufferIdˢ) Schema() *schema.Class       { return schemaFramebufferIdˢ }

var schemaFramebufferIdˢ = &schema.Class{
	TypeID:  binaryIDFramebufferIdˢ,
	Package: "gles",
	Name:    "FramebufferIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassFramebufferIdᵖ struct{}

func (*FramebufferIdᵖ) Class() binary.Class {
	return (*binaryClassFramebufferIdᵖ)(nil)
}
func doEncodeFramebufferIdᵖ(e binary.Encoder, o *FramebufferIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeFramebufferIdᵖ(d binary.Decoder, o *FramebufferIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipFramebufferIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFramebufferIdᵖ) ID() binary.ID      { return binaryIDFramebufferIdᵖ }
func (*binaryClassFramebufferIdᵖ) New() binary.Object { return &FramebufferIdᵖ{} }
func (*binaryClassFramebufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFramebufferIdᵖ(e, obj.(*FramebufferIdᵖ))
}
func (*binaryClassFramebufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FramebufferIdᵖ{}
	return obj, doDecodeFramebufferIdᵖ(d, obj)
}
func (*binaryClassFramebufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFramebufferIdᵖ(d, obj.(*FramebufferIdᵖ))
}
func (*binaryClassFramebufferIdᵖ) Skip(d binary.Decoder) error { return doSkipFramebufferIdᵖ(d) }
func (*binaryClassFramebufferIdᵖ) Schema() *schema.Class       { return schemaFramebufferIdᵖ }

var schemaFramebufferIdᵖ = &schema.Class{
	TypeID:  binaryIDFramebufferIdᵖ,
	Package: "gles",
	Name:    "FramebufferIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassFramebufferIdᶜᵖ struct{}

func (*FramebufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassFramebufferIdᶜᵖ)(nil)
}
func doEncodeFramebufferIdᶜᵖ(e binary.Encoder, o *FramebufferIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeFramebufferIdᶜᵖ(d binary.Decoder, o *FramebufferIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipFramebufferIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFramebufferIdᶜᵖ) ID() binary.ID      { return binaryIDFramebufferIdᶜᵖ }
func (*binaryClassFramebufferIdᶜᵖ) New() binary.Object { return &FramebufferIdᶜᵖ{} }
func (*binaryClassFramebufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFramebufferIdᶜᵖ(e, obj.(*FramebufferIdᶜᵖ))
}
func (*binaryClassFramebufferIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FramebufferIdᶜᵖ{}
	return obj, doDecodeFramebufferIdᶜᵖ(d, obj)
}
func (*binaryClassFramebufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFramebufferIdᶜᵖ(d, obj.(*FramebufferIdᶜᵖ))
}
func (*binaryClassFramebufferIdᶜᵖ) Skip(d binary.Decoder) error {
	return doSkipFramebufferIdᶜᵖ(d)
}
func (*binaryClassFramebufferIdᶜᵖ) Schema() *schema.Class { return schemaFramebufferIdᶜᵖ }

var schemaFramebufferIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDFramebufferIdᶜᵖ,
	Package: "gles",
	Name:    "FramebufferIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLDEBUGPROCKHR struct{}

func (*GLDEBUGPROCKHR) Class() binary.Class {
	return (*binaryClassGLDEBUGPROCKHR)(nil)
}
func doEncodeGLDEBUGPROCKHR(e binary.Encoder, o *GLDEBUGPROCKHR) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLDEBUGPROCKHR(d binary.Decoder, o *GLDEBUGPROCKHR) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLDEBUGPROCKHR(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLDEBUGPROCKHR) ID() binary.ID      { return binaryIDGLDEBUGPROCKHR }
func (*binaryClassGLDEBUGPROCKHR) New() binary.Object { return &GLDEBUGPROCKHR{} }
func (*binaryClassGLDEBUGPROCKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLDEBUGPROCKHR(e, obj.(*GLDEBUGPROCKHR))
}
func (*binaryClassGLDEBUGPROCKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLDEBUGPROCKHR{}
	return obj, doDecodeGLDEBUGPROCKHR(d, obj)
}
func (*binaryClassGLDEBUGPROCKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLDEBUGPROCKHR(d, obj.(*GLDEBUGPROCKHR))
}
func (*binaryClassGLDEBUGPROCKHR) Skip(d binary.Decoder) error { return doSkipGLDEBUGPROCKHR(d) }
func (*binaryClassGLDEBUGPROCKHR) Schema() *schema.Class       { return schemaGLDEBUGPROCKHR }

var schemaGLDEBUGPROCKHR = &schema.Class{
	TypeID:  binaryIDGLDEBUGPROCKHR,
	Package: "gles",
	Name:    "GLDEBUGPROCKHR",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLXContext struct{}

func (*GLXContext) Class() binary.Class {
	return (*binaryClassGLXContext)(nil)
}
func doEncodeGLXContext(e binary.Encoder, o *GLXContext) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLXContext(d binary.Decoder, o *GLXContext) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLXContext(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLXContext) ID() binary.ID      { return binaryIDGLXContext }
func (*binaryClassGLXContext) New() binary.Object { return &GLXContext{} }
func (*binaryClassGLXContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLXContext(e, obj.(*GLXContext))
}
func (*binaryClassGLXContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLXContext{}
	return obj, doDecodeGLXContext(d, obj)
}
func (*binaryClassGLXContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLXContext(d, obj.(*GLXContext))
}
func (*binaryClassGLXContext) Skip(d binary.Decoder) error { return doSkipGLXContext(d) }
func (*binaryClassGLXContext) Schema() *schema.Class       { return schemaGLXContext }

var schemaGLXContext = &schema.Class{
	TypeID:  binaryIDGLXContext,
	Package: "gles",
	Name:    "GLXContext",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLXDrawable struct{}

func (*GLXDrawable) Class() binary.Class {
	return (*binaryClassGLXDrawable)(nil)
}
func doEncodeGLXDrawable(e binary.Encoder, o *GLXDrawable) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLXDrawable(d binary.Decoder, o *GLXDrawable) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLXDrawable(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLXDrawable) ID() binary.ID      { return binaryIDGLXDrawable }
func (*binaryClassGLXDrawable) New() binary.Object { return &GLXDrawable{} }
func (*binaryClassGLXDrawable) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLXDrawable(e, obj.(*GLXDrawable))
}
func (*binaryClassGLXDrawable) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLXDrawable{}
	return obj, doDecodeGLXDrawable(d, obj)
}
func (*binaryClassGLXDrawable) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLXDrawable(d, obj.(*GLXDrawable))
}
func (*binaryClassGLXDrawable) Skip(d binary.Decoder) error { return doSkipGLXDrawable(d) }
func (*binaryClassGLXDrawable) Schema() *schema.Class       { return schemaGLXDrawable }

var schemaGLXDrawable = &schema.Class{
	TypeID:  binaryIDGLXDrawable,
	Package: "gles",
	Name:    "GLXDrawable",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLbooleanˢ struct{}

func (*GLbooleanˢ) Class() binary.Class {
	return (*binaryClassGLbooleanˢ)(nil)
}
func doEncodeGLbooleanˢ(e binary.Encoder, o *GLbooleanˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLbooleanˢ(d binary.Decoder, o *GLbooleanˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLbooleanˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLbooleanˢ) ID() binary.ID      { return binaryIDGLbooleanˢ }
func (*binaryClassGLbooleanˢ) New() binary.Object { return &GLbooleanˢ{} }
func (*binaryClassGLbooleanˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLbooleanˢ(e, obj.(*GLbooleanˢ))
}
func (*binaryClassGLbooleanˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLbooleanˢ{}
	return obj, doDecodeGLbooleanˢ(d, obj)
}
func (*binaryClassGLbooleanˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLbooleanˢ(d, obj.(*GLbooleanˢ))
}
func (*binaryClassGLbooleanˢ) Skip(d binary.Decoder) error { return doSkipGLbooleanˢ(d) }
func (*binaryClassGLbooleanˢ) Schema() *schema.Class       { return schemaGLbooleanˢ }

var schemaGLbooleanˢ = &schema.Class{
	TypeID:  binaryIDGLbooleanˢ,
	Package: "gles",
	Name:    "GLbooleanˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLbooleanᵖ struct{}

func (*GLbooleanᵖ) Class() binary.Class {
	return (*binaryClassGLbooleanᵖ)(nil)
}
func doEncodeGLbooleanᵖ(e binary.Encoder, o *GLbooleanᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLbooleanᵖ(d binary.Decoder, o *GLbooleanᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLbooleanᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLbooleanᵖ) ID() binary.ID      { return binaryIDGLbooleanᵖ }
func (*binaryClassGLbooleanᵖ) New() binary.Object { return &GLbooleanᵖ{} }
func (*binaryClassGLbooleanᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLbooleanᵖ(e, obj.(*GLbooleanᵖ))
}
func (*binaryClassGLbooleanᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLbooleanᵖ{}
	return obj, doDecodeGLbooleanᵖ(d, obj)
}
func (*binaryClassGLbooleanᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLbooleanᵖ(d, obj.(*GLbooleanᵖ))
}
func (*binaryClassGLbooleanᵖ) Skip(d binary.Decoder) error { return doSkipGLbooleanᵖ(d) }
func (*binaryClassGLbooleanᵖ) Schema() *schema.Class       { return schemaGLbooleanᵖ }

var schemaGLbooleanᵖ = &schema.Class{
	TypeID:  binaryIDGLbooleanᵖ,
	Package: "gles",
	Name:    "GLbooleanᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLcharᵖ struct{}

func (*GLcharᵖ) Class() binary.Class {
	return (*binaryClassGLcharᵖ)(nil)
}
func doEncodeGLcharᵖ(e binary.Encoder, o *GLcharᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharᵖ(d binary.Decoder, o *GLcharᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharᵖ) ID() binary.ID      { return binaryIDGLcharᵖ }
func (*binaryClassGLcharᵖ) New() binary.Object { return &GLcharᵖ{} }
func (*binaryClassGLcharᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharᵖ(e, obj.(*GLcharᵖ))
}
func (*binaryClassGLcharᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharᵖ{}
	return obj, doDecodeGLcharᵖ(d, obj)
}
func (*binaryClassGLcharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharᵖ(d, obj.(*GLcharᵖ))
}
func (*binaryClassGLcharᵖ) Skip(d binary.Decoder) error { return doSkipGLcharᵖ(d) }
func (*binaryClassGLcharᵖ) Schema() *schema.Class       { return schemaGLcharᵖ }

var schemaGLcharᵖ = &schema.Class{
	TypeID:  binaryIDGLcharᵖ,
	Package: "gles",
	Name:    "GLcharᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLcharᶜᵖ struct{}

func (*GLcharᶜᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖ)(nil)
}
func doEncodeGLcharᶜᵖ(e binary.Encoder, o *GLcharᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharᶜᵖ(d binary.Decoder, o *GLcharᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharᶜᵖ) ID() binary.ID      { return binaryIDGLcharᶜᵖ }
func (*binaryClassGLcharᶜᵖ) New() binary.Object { return &GLcharᶜᵖ{} }
func (*binaryClassGLcharᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharᶜᵖ(e, obj.(*GLcharᶜᵖ))
}
func (*binaryClassGLcharᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharᶜᵖ{}
	return obj, doDecodeGLcharᶜᵖ(d, obj)
}
func (*binaryClassGLcharᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharᶜᵖ(d, obj.(*GLcharᶜᵖ))
}
func (*binaryClassGLcharᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLcharᶜᵖ(d) }
func (*binaryClassGLcharᶜᵖ) Schema() *schema.Class       { return schemaGLcharᶜᵖ }

var schemaGLcharᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLcharᶜᵖ,
	Package: "gles",
	Name:    "GLcharᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLcharᶜᵖˢ struct{}

func (*GLcharᶜᵖˢ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖˢ)(nil)
}
func doEncodeGLcharᶜᵖˢ(e binary.Encoder, o *GLcharᶜᵖˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharᶜᵖˢ(d binary.Decoder, o *GLcharᶜᵖˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharᶜᵖˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharᶜᵖˢ) ID() binary.ID      { return binaryIDGLcharᶜᵖˢ }
func (*binaryClassGLcharᶜᵖˢ) New() binary.Object { return &GLcharᶜᵖˢ{} }
func (*binaryClassGLcharᶜᵖˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharᶜᵖˢ(e, obj.(*GLcharᶜᵖˢ))
}
func (*binaryClassGLcharᶜᵖˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharᶜᵖˢ{}
	return obj, doDecodeGLcharᶜᵖˢ(d, obj)
}
func (*binaryClassGLcharᶜᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharᶜᵖˢ(d, obj.(*GLcharᶜᵖˢ))
}
func (*binaryClassGLcharᶜᵖˢ) Skip(d binary.Decoder) error { return doSkipGLcharᶜᵖˢ(d) }
func (*binaryClassGLcharᶜᵖˢ) Schema() *schema.Class       { return schemaGLcharᶜᵖˢ }

var schemaGLcharᶜᵖˢ = &schema.Class{
	TypeID:  binaryIDGLcharᶜᵖˢ,
	Package: "gles",
	Name:    "GLcharᶜᵖˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLcharᶜᵖᵖ struct{}

func (*GLcharᶜᵖᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖᵖ)(nil)
}
func doEncodeGLcharᶜᵖᵖ(e binary.Encoder, o *GLcharᶜᵖᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharᶜᵖᵖ(d binary.Decoder, o *GLcharᶜᵖᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharᶜᵖᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharᶜᵖᵖ) ID() binary.ID      { return binaryIDGLcharᶜᵖᵖ }
func (*binaryClassGLcharᶜᵖᵖ) New() binary.Object { return &GLcharᶜᵖᵖ{} }
func (*binaryClassGLcharᶜᵖᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharᶜᵖᵖ(e, obj.(*GLcharᶜᵖᵖ))
}
func (*binaryClassGLcharᶜᵖᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharᶜᵖᵖ{}
	return obj, doDecodeGLcharᶜᵖᵖ(d, obj)
}
func (*binaryClassGLcharᶜᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharᶜᵖᵖ(d, obj.(*GLcharᶜᵖᵖ))
}
func (*binaryClassGLcharᶜᵖᵖ) Skip(d binary.Decoder) error { return doSkipGLcharᶜᵖᵖ(d) }
func (*binaryClassGLcharᶜᵖᵖ) Schema() *schema.Class       { return schemaGLcharᶜᵖᵖ }

var schemaGLcharᶜᵖᵖ = &schema.Class{
	TypeID:  binaryIDGLcharᶜᵖᵖ,
	Package: "gles",
	Name:    "GLcharᶜᵖᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLcharᶜᵖᶜᵖ struct{}

func (*GLcharᶜᵖᶜᵖ) Class() binary.Class {
	return (*binaryClassGLcharᶜᵖᶜᵖ)(nil)
}
func doEncodeGLcharᶜᵖᶜᵖ(e binary.Encoder, o *GLcharᶜᵖᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLcharᶜᵖᶜᵖ(d binary.Decoder, o *GLcharᶜᵖᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLcharᶜᵖᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLcharᶜᵖᶜᵖ) ID() binary.ID      { return binaryIDGLcharᶜᵖᶜᵖ }
func (*binaryClassGLcharᶜᵖᶜᵖ) New() binary.Object { return &GLcharᶜᵖᶜᵖ{} }
func (*binaryClassGLcharᶜᵖᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLcharᶜᵖᶜᵖ(e, obj.(*GLcharᶜᵖᶜᵖ))
}
func (*binaryClassGLcharᶜᵖᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLcharᶜᵖᶜᵖ{}
	return obj, doDecodeGLcharᶜᵖᶜᵖ(d, obj)
}
func (*binaryClassGLcharᶜᵖᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLcharᶜᵖᶜᵖ(d, obj.(*GLcharᶜᵖᶜᵖ))
}
func (*binaryClassGLcharᶜᵖᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLcharᶜᵖᶜᵖ(d) }
func (*binaryClassGLcharᶜᵖᶜᵖ) Schema() *schema.Class       { return schemaGLcharᶜᵖᶜᵖ }

var schemaGLcharᶜᵖᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLcharᶜᵖᶜᵖ,
	Package: "gles",
	Name:    "GLcharᶜᵖᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLeglImageOES struct{}

func (*GLeglImageOES) Class() binary.Class {
	return (*binaryClassGLeglImageOES)(nil)
}
func doEncodeGLeglImageOES(e binary.Encoder, o *GLeglImageOES) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLeglImageOES(d binary.Decoder, o *GLeglImageOES) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLeglImageOES(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLeglImageOES) ID() binary.ID      { return binaryIDGLeglImageOES }
func (*binaryClassGLeglImageOES) New() binary.Object { return &GLeglImageOES{} }
func (*binaryClassGLeglImageOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLeglImageOES(e, obj.(*GLeglImageOES))
}
func (*binaryClassGLeglImageOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLeglImageOES{}
	return obj, doDecodeGLeglImageOES(d, obj)
}
func (*binaryClassGLeglImageOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLeglImageOES(d, obj.(*GLeglImageOES))
}
func (*binaryClassGLeglImageOES) Skip(d binary.Decoder) error { return doSkipGLeglImageOES(d) }
func (*binaryClassGLeglImageOES) Schema() *schema.Class       { return schemaGLeglImageOES }

var schemaGLeglImageOES = &schema.Class{
	TypeID:  binaryIDGLeglImageOES,
	Package: "gles",
	Name:    "GLeglImageOES",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLenumˢ struct{}

func (*GLenumˢ) Class() binary.Class {
	return (*binaryClassGLenumˢ)(nil)
}
func doEncodeGLenumˢ(e binary.Encoder, o *GLenumˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLenumˢ(d binary.Decoder, o *GLenumˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLenumˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLenumˢ) ID() binary.ID      { return binaryIDGLenumˢ }
func (*binaryClassGLenumˢ) New() binary.Object { return &GLenumˢ{} }
func (*binaryClassGLenumˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLenumˢ(e, obj.(*GLenumˢ))
}
func (*binaryClassGLenumˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLenumˢ{}
	return obj, doDecodeGLenumˢ(d, obj)
}
func (*binaryClassGLenumˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLenumˢ(d, obj.(*GLenumˢ))
}
func (*binaryClassGLenumˢ) Skip(d binary.Decoder) error { return doSkipGLenumˢ(d) }
func (*binaryClassGLenumˢ) Schema() *schema.Class       { return schemaGLenumˢ }

var schemaGLenumˢ = &schema.Class{
	TypeID:  binaryIDGLenumˢ,
	Package: "gles",
	Name:    "GLenumˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLenumᵖ struct{}

func (*GLenumᵖ) Class() binary.Class {
	return (*binaryClassGLenumᵖ)(nil)
}
func doEncodeGLenumᵖ(e binary.Encoder, o *GLenumᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLenumᵖ(d binary.Decoder, o *GLenumᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLenumᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLenumᵖ) ID() binary.ID      { return binaryIDGLenumᵖ }
func (*binaryClassGLenumᵖ) New() binary.Object { return &GLenumᵖ{} }
func (*binaryClassGLenumᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLenumᵖ(e, obj.(*GLenumᵖ))
}
func (*binaryClassGLenumᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLenumᵖ{}
	return obj, doDecodeGLenumᵖ(d, obj)
}
func (*binaryClassGLenumᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLenumᵖ(d, obj.(*GLenumᵖ))
}
func (*binaryClassGLenumᵖ) Skip(d binary.Decoder) error { return doSkipGLenumᵖ(d) }
func (*binaryClassGLenumᵖ) Schema() *schema.Class       { return schemaGLenumᵖ }

var schemaGLenumᵖ = &schema.Class{
	TypeID:  binaryIDGLenumᵖ,
	Package: "gles",
	Name:    "GLenumᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLenumᶜᵖ struct{}

func (*GLenumᶜᵖ) Class() binary.Class {
	return (*binaryClassGLenumᶜᵖ)(nil)
}
func doEncodeGLenumᶜᵖ(e binary.Encoder, o *GLenumᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLenumᶜᵖ(d binary.Decoder, o *GLenumᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLenumᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLenumᶜᵖ) ID() binary.ID      { return binaryIDGLenumᶜᵖ }
func (*binaryClassGLenumᶜᵖ) New() binary.Object { return &GLenumᶜᵖ{} }
func (*binaryClassGLenumᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLenumᶜᵖ(e, obj.(*GLenumᶜᵖ))
}
func (*binaryClassGLenumᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLenumᶜᵖ{}
	return obj, doDecodeGLenumᶜᵖ(d, obj)
}
func (*binaryClassGLenumᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLenumᶜᵖ(d, obj.(*GLenumᶜᵖ))
}
func (*binaryClassGLenumᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLenumᶜᵖ(d) }
func (*binaryClassGLenumᶜᵖ) Schema() *schema.Class       { return schemaGLenumᶜᵖ }

var schemaGLenumᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLenumᶜᵖ,
	Package: "gles",
	Name:    "GLenumᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLfloatː2ᵃ struct{}

func (*GLfloatː2ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː2ᵃ)(nil)
}
func doEncodeGLfloatː2ᵃ(e binary.Encoder, o *GLfloatː2ᵃ) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLfloatː2ᵃ(d binary.Decoder, o *GLfloatː2ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipGLfloatː2ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLfloatː2ᵃ) ID() binary.ID      { return binaryIDGLfloatː2ᵃ }
func (*binaryClassGLfloatː2ᵃ) New() binary.Object { return &GLfloatː2ᵃ{} }
func (*binaryClassGLfloatː2ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatː2ᵃ(e, obj.(*GLfloatː2ᵃ))
}
func (*binaryClassGLfloatː2ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatː2ᵃ{}
	return obj, doDecodeGLfloatː2ᵃ(d, obj)
}
func (*binaryClassGLfloatː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatː2ᵃ(d, obj.(*GLfloatː2ᵃ))
}
func (*binaryClassGLfloatː2ᵃ) Skip(d binary.Decoder) error { return doSkipGLfloatː2ᵃ(d) }
func (*binaryClassGLfloatː2ᵃ) Schema() *schema.Class       { return schemaGLfloatː2ᵃ }

var schemaGLfloatː2ᵃ = &schema.Class{
	TypeID:  binaryIDGLfloatː2ᵃ,
	Package: "gles",
	Name:    "GLfloatː2ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 2}},
	},
}

type binaryClassGLfloatː3ᵃ struct{}

func (*GLfloatː3ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː3ᵃ)(nil)
}
func doEncodeGLfloatː3ᵃ(e binary.Encoder, o *GLfloatː3ᵃ) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLfloatː3ᵃ(d binary.Decoder, o *GLfloatː3ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipGLfloatː3ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLfloatː3ᵃ) ID() binary.ID      { return binaryIDGLfloatː3ᵃ }
func (*binaryClassGLfloatː3ᵃ) New() binary.Object { return &GLfloatː3ᵃ{} }
func (*binaryClassGLfloatː3ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatː3ᵃ(e, obj.(*GLfloatː3ᵃ))
}
func (*binaryClassGLfloatː3ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatː3ᵃ{}
	return obj, doDecodeGLfloatː3ᵃ(d, obj)
}
func (*binaryClassGLfloatː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatː3ᵃ(d, obj.(*GLfloatː3ᵃ))
}
func (*binaryClassGLfloatː3ᵃ) Skip(d binary.Decoder) error { return doSkipGLfloatː3ᵃ(d) }
func (*binaryClassGLfloatː3ᵃ) Schema() *schema.Class       { return schemaGLfloatː3ᵃ }

var schemaGLfloatː3ᵃ = &schema.Class{
	TypeID:  binaryIDGLfloatː3ᵃ,
	Package: "gles",
	Name:    "GLfloatː3ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 3}},
	},
}

type binaryClassGLfloatː4ᵃ struct{}

func (*GLfloatː4ᵃ) Class() binary.Class {
	return (*binaryClassGLfloatː4ᵃ)(nil)
}
func doEncodeGLfloatː4ᵃ(e binary.Encoder, o *GLfloatː4ᵃ) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLfloatː4ᵃ(d binary.Decoder, o *GLfloatː4ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipGLfloatː4ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLfloatː4ᵃ) ID() binary.ID      { return binaryIDGLfloatː4ᵃ }
func (*binaryClassGLfloatː4ᵃ) New() binary.Object { return &GLfloatː4ᵃ{} }
func (*binaryClassGLfloatː4ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatː4ᵃ(e, obj.(*GLfloatː4ᵃ))
}
func (*binaryClassGLfloatː4ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatː4ᵃ{}
	return obj, doDecodeGLfloatː4ᵃ(d, obj)
}
func (*binaryClassGLfloatː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatː4ᵃ(d, obj.(*GLfloatː4ᵃ))
}
func (*binaryClassGLfloatː4ᵃ) Skip(d binary.Decoder) error { return doSkipGLfloatː4ᵃ(d) }
func (*binaryClassGLfloatː4ᵃ) Schema() *schema.Class       { return schemaGLfloatː4ᵃ }

var schemaGLfloatː4ᵃ = &schema.Class{
	TypeID:  binaryIDGLfloatː4ᵃ,
	Package: "gles",
	Name:    "GLfloatː4ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 4}},
	},
}

type binaryClassGLfloatˢ struct{}

func (*GLfloatˢ) Class() binary.Class {
	return (*binaryClassGLfloatˢ)(nil)
}
func doEncodeGLfloatˢ(e binary.Encoder, o *GLfloatˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLfloatˢ(d binary.Decoder, o *GLfloatˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLfloatˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLfloatˢ) ID() binary.ID      { return binaryIDGLfloatˢ }
func (*binaryClassGLfloatˢ) New() binary.Object { return &GLfloatˢ{} }
func (*binaryClassGLfloatˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatˢ(e, obj.(*GLfloatˢ))
}
func (*binaryClassGLfloatˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatˢ{}
	return obj, doDecodeGLfloatˢ(d, obj)
}
func (*binaryClassGLfloatˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatˢ(d, obj.(*GLfloatˢ))
}
func (*binaryClassGLfloatˢ) Skip(d binary.Decoder) error { return doSkipGLfloatˢ(d) }
func (*binaryClassGLfloatˢ) Schema() *schema.Class       { return schemaGLfloatˢ }

var schemaGLfloatˢ = &schema.Class{
	TypeID:  binaryIDGLfloatˢ,
	Package: "gles",
	Name:    "GLfloatˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLfloatᵖ struct{}

func (*GLfloatᵖ) Class() binary.Class {
	return (*binaryClassGLfloatᵖ)(nil)
}
func doEncodeGLfloatᵖ(e binary.Encoder, o *GLfloatᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLfloatᵖ(d binary.Decoder, o *GLfloatᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLfloatᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLfloatᵖ) ID() binary.ID      { return binaryIDGLfloatᵖ }
func (*binaryClassGLfloatᵖ) New() binary.Object { return &GLfloatᵖ{} }
func (*binaryClassGLfloatᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatᵖ(e, obj.(*GLfloatᵖ))
}
func (*binaryClassGLfloatᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatᵖ{}
	return obj, doDecodeGLfloatᵖ(d, obj)
}
func (*binaryClassGLfloatᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatᵖ(d, obj.(*GLfloatᵖ))
}
func (*binaryClassGLfloatᵖ) Skip(d binary.Decoder) error { return doSkipGLfloatᵖ(d) }
func (*binaryClassGLfloatᵖ) Schema() *schema.Class       { return schemaGLfloatᵖ }

var schemaGLfloatᵖ = &schema.Class{
	TypeID:  binaryIDGLfloatᵖ,
	Package: "gles",
	Name:    "GLfloatᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLfloatᶜᵖ struct{}

func (*GLfloatᶜᵖ) Class() binary.Class {
	return (*binaryClassGLfloatᶜᵖ)(nil)
}
func doEncodeGLfloatᶜᵖ(e binary.Encoder, o *GLfloatᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLfloatᶜᵖ(d binary.Decoder, o *GLfloatᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLfloatᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLfloatᶜᵖ) ID() binary.ID      { return binaryIDGLfloatᶜᵖ }
func (*binaryClassGLfloatᶜᵖ) New() binary.Object { return &GLfloatᶜᵖ{} }
func (*binaryClassGLfloatᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLfloatᶜᵖ(e, obj.(*GLfloatᶜᵖ))
}
func (*binaryClassGLfloatᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLfloatᶜᵖ{}
	return obj, doDecodeGLfloatᶜᵖ(d, obj)
}
func (*binaryClassGLfloatᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLfloatᶜᵖ(d, obj.(*GLfloatᶜᵖ))
}
func (*binaryClassGLfloatᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLfloatᶜᵖ(d) }
func (*binaryClassGLfloatᶜᵖ) Schema() *schema.Class       { return schemaGLfloatᶜᵖ }

var schemaGLfloatᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLfloatᶜᵖ,
	Package: "gles",
	Name:    "GLfloatᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLint64ˢ struct{}

func (*GLint64ˢ) Class() binary.Class {
	return (*binaryClassGLint64ˢ)(nil)
}
func doEncodeGLint64ˢ(e binary.Encoder, o *GLint64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLint64ˢ(d binary.Decoder, o *GLint64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLint64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLint64ˢ) ID() binary.ID      { return binaryIDGLint64ˢ }
func (*binaryClassGLint64ˢ) New() binary.Object { return &GLint64ˢ{} }
func (*binaryClassGLint64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLint64ˢ(e, obj.(*GLint64ˢ))
}
func (*binaryClassGLint64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLint64ˢ{}
	return obj, doDecodeGLint64ˢ(d, obj)
}
func (*binaryClassGLint64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLint64ˢ(d, obj.(*GLint64ˢ))
}
func (*binaryClassGLint64ˢ) Skip(d binary.Decoder) error { return doSkipGLint64ˢ(d) }
func (*binaryClassGLint64ˢ) Schema() *schema.Class       { return schemaGLint64ˢ }

var schemaGLint64ˢ = &schema.Class{
	TypeID:  binaryIDGLint64ˢ,
	Package: "gles",
	Name:    "GLint64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLint64ᵖ struct{}

func (*GLint64ᵖ) Class() binary.Class {
	return (*binaryClassGLint64ᵖ)(nil)
}
func doEncodeGLint64ᵖ(e binary.Encoder, o *GLint64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLint64ᵖ(d binary.Decoder, o *GLint64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLint64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLint64ᵖ) ID() binary.ID      { return binaryIDGLint64ᵖ }
func (*binaryClassGLint64ᵖ) New() binary.Object { return &GLint64ᵖ{} }
func (*binaryClassGLint64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLint64ᵖ(e, obj.(*GLint64ᵖ))
}
func (*binaryClassGLint64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLint64ᵖ{}
	return obj, doDecodeGLint64ᵖ(d, obj)
}
func (*binaryClassGLint64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLint64ᵖ(d, obj.(*GLint64ᵖ))
}
func (*binaryClassGLint64ᵖ) Skip(d binary.Decoder) error { return doSkipGLint64ᵖ(d) }
func (*binaryClassGLint64ᵖ) Schema() *schema.Class       { return schemaGLint64ᵖ }

var schemaGLint64ᵖ = &schema.Class{
	TypeID:  binaryIDGLint64ᵖ,
	Package: "gles",
	Name:    "GLint64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLintː2ᵃ struct{}

func (*GLintː2ᵃ) Class() binary.Class {
	return (*binaryClassGLintː2ᵃ)(nil)
}
func doEncodeGLintː2ᵃ(e binary.Encoder, o *GLintː2ᵃ) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLintː2ᵃ(d binary.Decoder, o *GLintː2ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipGLintː2ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLintː2ᵃ) ID() binary.ID      { return binaryIDGLintː2ᵃ }
func (*binaryClassGLintː2ᵃ) New() binary.Object { return &GLintː2ᵃ{} }
func (*binaryClassGLintː2ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintː2ᵃ(e, obj.(*GLintː2ᵃ))
}
func (*binaryClassGLintː2ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintː2ᵃ{}
	return obj, doDecodeGLintː2ᵃ(d, obj)
}
func (*binaryClassGLintː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintː2ᵃ(d, obj.(*GLintː2ᵃ))
}
func (*binaryClassGLintː2ᵃ) Skip(d binary.Decoder) error { return doSkipGLintː2ᵃ(d) }
func (*binaryClassGLintː2ᵃ) Schema() *schema.Class       { return schemaGLintː2ᵃ }

var schemaGLintː2ᵃ = &schema.Class{
	TypeID:  binaryIDGLintː2ᵃ,
	Package: "gles",
	Name:    "GLintː2ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 2}},
	},
}

type binaryClassGLintː3ᵃ struct{}

func (*GLintː3ᵃ) Class() binary.Class {
	return (*binaryClassGLintː3ᵃ)(nil)
}
func doEncodeGLintː3ᵃ(e binary.Encoder, o *GLintː3ᵃ) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLintː3ᵃ(d binary.Decoder, o *GLintː3ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipGLintː3ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLintː3ᵃ) ID() binary.ID      { return binaryIDGLintː3ᵃ }
func (*binaryClassGLintː3ᵃ) New() binary.Object { return &GLintː3ᵃ{} }
func (*binaryClassGLintː3ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintː3ᵃ(e, obj.(*GLintː3ᵃ))
}
func (*binaryClassGLintː3ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintː3ᵃ{}
	return obj, doDecodeGLintː3ᵃ(d, obj)
}
func (*binaryClassGLintː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintː3ᵃ(d, obj.(*GLintː3ᵃ))
}
func (*binaryClassGLintː3ᵃ) Skip(d binary.Decoder) error { return doSkipGLintː3ᵃ(d) }
func (*binaryClassGLintː3ᵃ) Schema() *schema.Class       { return schemaGLintː3ᵃ }

var schemaGLintː3ᵃ = &schema.Class{
	TypeID:  binaryIDGLintː3ᵃ,
	Package: "gles",
	Name:    "GLintː3ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 3}},
	},
}

type binaryClassGLintː4ᵃ struct{}

func (*GLintː4ᵃ) Class() binary.Class {
	return (*binaryClassGLintː4ᵃ)(nil)
}
func doEncodeGLintː4ᵃ(e binary.Encoder, o *GLintː4ᵃ) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeGLintː4ᵃ(d binary.Decoder, o *GLintː4ᵃ) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipGLintː4ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassGLintː4ᵃ) ID() binary.ID      { return binaryIDGLintː4ᵃ }
func (*binaryClassGLintː4ᵃ) New() binary.Object { return &GLintː4ᵃ{} }
func (*binaryClassGLintː4ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintː4ᵃ(e, obj.(*GLintː4ᵃ))
}
func (*binaryClassGLintː4ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintː4ᵃ{}
	return obj, doDecodeGLintː4ᵃ(d, obj)
}
func (*binaryClassGLintː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintː4ᵃ(d, obj.(*GLintː4ᵃ))
}
func (*binaryClassGLintː4ᵃ) Skip(d binary.Decoder) error { return doSkipGLintː4ᵃ(d) }
func (*binaryClassGLintː4ᵃ) Schema() *schema.Class       { return schemaGLintː4ᵃ }

var schemaGLintː4ᵃ = &schema.Class{
	TypeID:  binaryIDGLintː4ᵃ,
	Package: "gles",
	Name:    "GLintː4ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 4}},
	},
}

type binaryClassGLintˢ struct{}

func (*GLintˢ) Class() binary.Class {
	return (*binaryClassGLintˢ)(nil)
}
func doEncodeGLintˢ(e binary.Encoder, o *GLintˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLintˢ(d binary.Decoder, o *GLintˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLintˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLintˢ) ID() binary.ID      { return binaryIDGLintˢ }
func (*binaryClassGLintˢ) New() binary.Object { return &GLintˢ{} }
func (*binaryClassGLintˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintˢ(e, obj.(*GLintˢ))
}
func (*binaryClassGLintˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintˢ{}
	return obj, doDecodeGLintˢ(d, obj)
}
func (*binaryClassGLintˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintˢ(d, obj.(*GLintˢ))
}
func (*binaryClassGLintˢ) Skip(d binary.Decoder) error { return doSkipGLintˢ(d) }
func (*binaryClassGLintˢ) Schema() *schema.Class       { return schemaGLintˢ }

var schemaGLintˢ = &schema.Class{
	TypeID:  binaryIDGLintˢ,
	Package: "gles",
	Name:    "GLintˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLintᵖ struct{}

func (*GLintᵖ) Class() binary.Class {
	return (*binaryClassGLintᵖ)(nil)
}
func doEncodeGLintᵖ(e binary.Encoder, o *GLintᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLintᵖ(d binary.Decoder, o *GLintᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLintᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLintᵖ) ID() binary.ID      { return binaryIDGLintᵖ }
func (*binaryClassGLintᵖ) New() binary.Object { return &GLintᵖ{} }
func (*binaryClassGLintᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintᵖ(e, obj.(*GLintᵖ))
}
func (*binaryClassGLintᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintᵖ{}
	return obj, doDecodeGLintᵖ(d, obj)
}
func (*binaryClassGLintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintᵖ(d, obj.(*GLintᵖ))
}
func (*binaryClassGLintᵖ) Skip(d binary.Decoder) error { return doSkipGLintᵖ(d) }
func (*binaryClassGLintᵖ) Schema() *schema.Class       { return schemaGLintᵖ }

var schemaGLintᵖ = &schema.Class{
	TypeID:  binaryIDGLintᵖ,
	Package: "gles",
	Name:    "GLintᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLintᶜᵖ struct{}

func (*GLintᶜᵖ) Class() binary.Class {
	return (*binaryClassGLintᶜᵖ)(nil)
}
func doEncodeGLintᶜᵖ(e binary.Encoder, o *GLintᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLintᶜᵖ(d binary.Decoder, o *GLintᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLintᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLintᶜᵖ) ID() binary.ID      { return binaryIDGLintᶜᵖ }
func (*binaryClassGLintᶜᵖ) New() binary.Object { return &GLintᶜᵖ{} }
func (*binaryClassGLintᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLintᶜᵖ(e, obj.(*GLintᶜᵖ))
}
func (*binaryClassGLintᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLintᶜᵖ{}
	return obj, doDecodeGLintᶜᵖ(d, obj)
}
func (*binaryClassGLintᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLintᶜᵖ(d, obj.(*GLintᶜᵖ))
}
func (*binaryClassGLintᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLintᶜᵖ(d) }
func (*binaryClassGLintᶜᵖ) Schema() *schema.Class       { return schemaGLintᶜᵖ }

var schemaGLintᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLintᶜᵖ,
	Package: "gles",
	Name:    "GLintᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLsizeiˢ struct{}

func (*GLsizeiˢ) Class() binary.Class {
	return (*binaryClassGLsizeiˢ)(nil)
}
func doEncodeGLsizeiˢ(e binary.Encoder, o *GLsizeiˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLsizeiˢ(d binary.Decoder, o *GLsizeiˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLsizeiˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLsizeiˢ) ID() binary.ID      { return binaryIDGLsizeiˢ }
func (*binaryClassGLsizeiˢ) New() binary.Object { return &GLsizeiˢ{} }
func (*binaryClassGLsizeiˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLsizeiˢ(e, obj.(*GLsizeiˢ))
}
func (*binaryClassGLsizeiˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLsizeiˢ{}
	return obj, doDecodeGLsizeiˢ(d, obj)
}
func (*binaryClassGLsizeiˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLsizeiˢ(d, obj.(*GLsizeiˢ))
}
func (*binaryClassGLsizeiˢ) Skip(d binary.Decoder) error { return doSkipGLsizeiˢ(d) }
func (*binaryClassGLsizeiˢ) Schema() *schema.Class       { return schemaGLsizeiˢ }

var schemaGLsizeiˢ = &schema.Class{
	TypeID:  binaryIDGLsizeiˢ,
	Package: "gles",
	Name:    "GLsizeiˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLsizeiᵖ struct{}

func (*GLsizeiᵖ) Class() binary.Class {
	return (*binaryClassGLsizeiᵖ)(nil)
}
func doEncodeGLsizeiᵖ(e binary.Encoder, o *GLsizeiᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLsizeiᵖ(d binary.Decoder, o *GLsizeiᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLsizeiᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLsizeiᵖ) ID() binary.ID      { return binaryIDGLsizeiᵖ }
func (*binaryClassGLsizeiᵖ) New() binary.Object { return &GLsizeiᵖ{} }
func (*binaryClassGLsizeiᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLsizeiᵖ(e, obj.(*GLsizeiᵖ))
}
func (*binaryClassGLsizeiᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLsizeiᵖ{}
	return obj, doDecodeGLsizeiᵖ(d, obj)
}
func (*binaryClassGLsizeiᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLsizeiᵖ(d, obj.(*GLsizeiᵖ))
}
func (*binaryClassGLsizeiᵖ) Skip(d binary.Decoder) error { return doSkipGLsizeiᵖ(d) }
func (*binaryClassGLsizeiᵖ) Schema() *schema.Class       { return schemaGLsizeiᵖ }

var schemaGLsizeiᵖ = &schema.Class{
	TypeID:  binaryIDGLsizeiᵖ,
	Package: "gles",
	Name:    "GLsizeiᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLsizeiᶜᵖ struct{}

func (*GLsizeiᶜᵖ) Class() binary.Class {
	return (*binaryClassGLsizeiᶜᵖ)(nil)
}
func doEncodeGLsizeiᶜᵖ(e binary.Encoder, o *GLsizeiᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLsizeiᶜᵖ(d binary.Decoder, o *GLsizeiᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLsizeiᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLsizeiᶜᵖ) ID() binary.ID      { return binaryIDGLsizeiᶜᵖ }
func (*binaryClassGLsizeiᶜᵖ) New() binary.Object { return &GLsizeiᶜᵖ{} }
func (*binaryClassGLsizeiᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLsizeiᶜᵖ(e, obj.(*GLsizeiᶜᵖ))
}
func (*binaryClassGLsizeiᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLsizeiᶜᵖ{}
	return obj, doDecodeGLsizeiᶜᵖ(d, obj)
}
func (*binaryClassGLsizeiᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLsizeiᶜᵖ(d, obj.(*GLsizeiᶜᵖ))
}
func (*binaryClassGLsizeiᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLsizeiᶜᵖ(d) }
func (*binaryClassGLsizeiᶜᵖ) Schema() *schema.Class       { return schemaGLsizeiᶜᵖ }

var schemaGLsizeiᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLsizeiᶜᵖ,
	Package: "gles",
	Name:    "GLsizeiᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLubyteˢ struct{}

func (*GLubyteˢ) Class() binary.Class {
	return (*binaryClassGLubyteˢ)(nil)
}
func doEncodeGLubyteˢ(e binary.Encoder, o *GLubyteˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLubyteˢ(d binary.Decoder, o *GLubyteˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLubyteˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLubyteˢ) ID() binary.ID      { return binaryIDGLubyteˢ }
func (*binaryClassGLubyteˢ) New() binary.Object { return &GLubyteˢ{} }
func (*binaryClassGLubyteˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLubyteˢ(e, obj.(*GLubyteˢ))
}
func (*binaryClassGLubyteˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLubyteˢ{}
	return obj, doDecodeGLubyteˢ(d, obj)
}
func (*binaryClassGLubyteˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLubyteˢ(d, obj.(*GLubyteˢ))
}
func (*binaryClassGLubyteˢ) Skip(d binary.Decoder) error { return doSkipGLubyteˢ(d) }
func (*binaryClassGLubyteˢ) Schema() *schema.Class       { return schemaGLubyteˢ }

var schemaGLubyteˢ = &schema.Class{
	TypeID:  binaryIDGLubyteˢ,
	Package: "gles",
	Name:    "GLubyteˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLubyteᵖ struct{}

func (*GLubyteᵖ) Class() binary.Class {
	return (*binaryClassGLubyteᵖ)(nil)
}
func doEncodeGLubyteᵖ(e binary.Encoder, o *GLubyteᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLubyteᵖ(d binary.Decoder, o *GLubyteᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLubyteᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLubyteᵖ) ID() binary.ID      { return binaryIDGLubyteᵖ }
func (*binaryClassGLubyteᵖ) New() binary.Object { return &GLubyteᵖ{} }
func (*binaryClassGLubyteᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLubyteᵖ(e, obj.(*GLubyteᵖ))
}
func (*binaryClassGLubyteᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLubyteᵖ{}
	return obj, doDecodeGLubyteᵖ(d, obj)
}
func (*binaryClassGLubyteᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLubyteᵖ(d, obj.(*GLubyteᵖ))
}
func (*binaryClassGLubyteᵖ) Skip(d binary.Decoder) error { return doSkipGLubyteᵖ(d) }
func (*binaryClassGLubyteᵖ) Schema() *schema.Class       { return schemaGLubyteᵖ }

var schemaGLubyteᵖ = &schema.Class{
	TypeID:  binaryIDGLubyteᵖ,
	Package: "gles",
	Name:    "GLubyteᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLubyteᶜᵖ struct{}

func (*GLubyteᶜᵖ) Class() binary.Class {
	return (*binaryClassGLubyteᶜᵖ)(nil)
}
func doEncodeGLubyteᶜᵖ(e binary.Encoder, o *GLubyteᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLubyteᶜᵖ(d binary.Decoder, o *GLubyteᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLubyteᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLubyteᶜᵖ) ID() binary.ID      { return binaryIDGLubyteᶜᵖ }
func (*binaryClassGLubyteᶜᵖ) New() binary.Object { return &GLubyteᶜᵖ{} }
func (*binaryClassGLubyteᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLubyteᶜᵖ(e, obj.(*GLubyteᶜᵖ))
}
func (*binaryClassGLubyteᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLubyteᶜᵖ{}
	return obj, doDecodeGLubyteᶜᵖ(d, obj)
}
func (*binaryClassGLubyteᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLubyteᶜᵖ(d, obj.(*GLubyteᶜᵖ))
}
func (*binaryClassGLubyteᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLubyteᶜᵖ(d) }
func (*binaryClassGLubyteᶜᵖ) Schema() *schema.Class       { return schemaGLubyteᶜᵖ }

var schemaGLubyteᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLubyteᶜᵖ,
	Package: "gles",
	Name:    "GLubyteᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLuint64ˢ struct{}

func (*GLuint64ˢ) Class() binary.Class {
	return (*binaryClassGLuint64ˢ)(nil)
}
func doEncodeGLuint64ˢ(e binary.Encoder, o *GLuint64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuint64ˢ(d binary.Decoder, o *GLuint64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLuint64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuint64ˢ) ID() binary.ID      { return binaryIDGLuint64ˢ }
func (*binaryClassGLuint64ˢ) New() binary.Object { return &GLuint64ˢ{} }
func (*binaryClassGLuint64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuint64ˢ(e, obj.(*GLuint64ˢ))
}
func (*binaryClassGLuint64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuint64ˢ{}
	return obj, doDecodeGLuint64ˢ(d, obj)
}
func (*binaryClassGLuint64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuint64ˢ(d, obj.(*GLuint64ˢ))
}
func (*binaryClassGLuint64ˢ) Skip(d binary.Decoder) error { return doSkipGLuint64ˢ(d) }
func (*binaryClassGLuint64ˢ) Schema() *schema.Class       { return schemaGLuint64ˢ }

var schemaGLuint64ˢ = &schema.Class{
	TypeID:  binaryIDGLuint64ˢ,
	Package: "gles",
	Name:    "GLuint64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLuint64ᵖ struct{}

func (*GLuint64ᵖ) Class() binary.Class {
	return (*binaryClassGLuint64ᵖ)(nil)
}
func doEncodeGLuint64ᵖ(e binary.Encoder, o *GLuint64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuint64ᵖ(d binary.Decoder, o *GLuint64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLuint64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuint64ᵖ) ID() binary.ID      { return binaryIDGLuint64ᵖ }
func (*binaryClassGLuint64ᵖ) New() binary.Object { return &GLuint64ᵖ{} }
func (*binaryClassGLuint64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuint64ᵖ(e, obj.(*GLuint64ᵖ))
}
func (*binaryClassGLuint64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuint64ᵖ{}
	return obj, doDecodeGLuint64ᵖ(d, obj)
}
func (*binaryClassGLuint64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuint64ᵖ(d, obj.(*GLuint64ᵖ))
}
func (*binaryClassGLuint64ᵖ) Skip(d binary.Decoder) error { return doSkipGLuint64ᵖ(d) }
func (*binaryClassGLuint64ᵖ) Schema() *schema.Class       { return schemaGLuint64ᵖ }

var schemaGLuint64ᵖ = &schema.Class{
	TypeID:  binaryIDGLuint64ᵖ,
	Package: "gles",
	Name:    "GLuint64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLuint64ᶜᵖ struct{}

func (*GLuint64ᶜᵖ) Class() binary.Class {
	return (*binaryClassGLuint64ᶜᵖ)(nil)
}
func doEncodeGLuint64ᶜᵖ(e binary.Encoder, o *GLuint64ᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuint64ᶜᵖ(d binary.Decoder, o *GLuint64ᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLuint64ᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuint64ᶜᵖ) ID() binary.ID      { return binaryIDGLuint64ᶜᵖ }
func (*binaryClassGLuint64ᶜᵖ) New() binary.Object { return &GLuint64ᶜᵖ{} }
func (*binaryClassGLuint64ᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuint64ᶜᵖ(e, obj.(*GLuint64ᶜᵖ))
}
func (*binaryClassGLuint64ᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuint64ᶜᵖ{}
	return obj, doDecodeGLuint64ᶜᵖ(d, obj)
}
func (*binaryClassGLuint64ᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuint64ᶜᵖ(d, obj.(*GLuint64ᶜᵖ))
}
func (*binaryClassGLuint64ᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLuint64ᶜᵖ(d) }
func (*binaryClassGLuint64ᶜᵖ) Schema() *schema.Class       { return schemaGLuint64ᶜᵖ }

var schemaGLuint64ᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLuint64ᶜᵖ,
	Package: "gles",
	Name:    "GLuint64ᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLuintˢ struct{}

func (*GLuintˢ) Class() binary.Class {
	return (*binaryClassGLuintˢ)(nil)
}
func doEncodeGLuintˢ(e binary.Encoder, o *GLuintˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuintˢ(d binary.Decoder, o *GLuintˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLuintˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuintˢ) ID() binary.ID      { return binaryIDGLuintˢ }
func (*binaryClassGLuintˢ) New() binary.Object { return &GLuintˢ{} }
func (*binaryClassGLuintˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuintˢ(e, obj.(*GLuintˢ))
}
func (*binaryClassGLuintˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuintˢ{}
	return obj, doDecodeGLuintˢ(d, obj)
}
func (*binaryClassGLuintˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuintˢ(d, obj.(*GLuintˢ))
}
func (*binaryClassGLuintˢ) Skip(d binary.Decoder) error { return doSkipGLuintˢ(d) }
func (*binaryClassGLuintˢ) Schema() *schema.Class       { return schemaGLuintˢ }

var schemaGLuintˢ = &schema.Class{
	TypeID:  binaryIDGLuintˢ,
	Package: "gles",
	Name:    "GLuintˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLuintᵖ struct{}

func (*GLuintᵖ) Class() binary.Class {
	return (*binaryClassGLuintᵖ)(nil)
}
func doEncodeGLuintᵖ(e binary.Encoder, o *GLuintᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuintᵖ(d binary.Decoder, o *GLuintᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLuintᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuintᵖ) ID() binary.ID      { return binaryIDGLuintᵖ }
func (*binaryClassGLuintᵖ) New() binary.Object { return &GLuintᵖ{} }
func (*binaryClassGLuintᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuintᵖ(e, obj.(*GLuintᵖ))
}
func (*binaryClassGLuintᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuintᵖ{}
	return obj, doDecodeGLuintᵖ(d, obj)
}
func (*binaryClassGLuintᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuintᵖ(d, obj.(*GLuintᵖ))
}
func (*binaryClassGLuintᵖ) Skip(d binary.Decoder) error { return doSkipGLuintᵖ(d) }
func (*binaryClassGLuintᵖ) Schema() *schema.Class       { return schemaGLuintᵖ }

var schemaGLuintᵖ = &schema.Class{
	TypeID:  binaryIDGLuintᵖ,
	Package: "gles",
	Name:    "GLuintᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLuintᶜᵖ struct{}

func (*GLuintᶜᵖ) Class() binary.Class {
	return (*binaryClassGLuintᶜᵖ)(nil)
}
func doEncodeGLuintᶜᵖ(e binary.Encoder, o *GLuintᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLuintᶜᵖ(d binary.Decoder, o *GLuintᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLuintᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLuintᶜᵖ) ID() binary.ID      { return binaryIDGLuintᶜᵖ }
func (*binaryClassGLuintᶜᵖ) New() binary.Object { return &GLuintᶜᵖ{} }
func (*binaryClassGLuintᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLuintᶜᵖ(e, obj.(*GLuintᶜᵖ))
}
func (*binaryClassGLuintᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLuintᶜᵖ{}
	return obj, doDecodeGLuintᶜᵖ(d, obj)
}
func (*binaryClassGLuintᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLuintᶜᵖ(d, obj.(*GLuintᶜᵖ))
}
func (*binaryClassGLuintᶜᵖ) Skip(d binary.Decoder) error { return doSkipGLuintᶜᵖ(d) }
func (*binaryClassGLuintᶜᵖ) Schema() *schema.Class       { return schemaGLuintᶜᵖ }

var schemaGLuintᶜᵖ = &schema.Class{
	TypeID:  binaryIDGLuintᶜᵖ,
	Package: "gles",
	Name:    "GLuintᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGLvoidˢ struct{}

func (*GLvoidˢ) Class() binary.Class {
	return (*binaryClassGLvoidˢ)(nil)
}
func doEncodeGLvoidˢ(e binary.Encoder, o *GLvoidˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeGLvoidˢ(d binary.Decoder, o *GLvoidˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipGLvoidˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLvoidˢ) ID() binary.ID      { return binaryIDGLvoidˢ }
func (*binaryClassGLvoidˢ) New() binary.Object { return &GLvoidˢ{} }
func (*binaryClassGLvoidˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLvoidˢ(e, obj.(*GLvoidˢ))
}
func (*binaryClassGLvoidˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLvoidˢ{}
	return obj, doDecodeGLvoidˢ(d, obj)
}
func (*binaryClassGLvoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLvoidˢ(d, obj.(*GLvoidˢ))
}
func (*binaryClassGLvoidˢ) Skip(d binary.Decoder) error { return doSkipGLvoidˢ(d) }
func (*binaryClassGLvoidˢ) Schema() *schema.Class       { return schemaGLvoidˢ }

var schemaGLvoidˢ = &schema.Class{
	TypeID:  binaryIDGLvoidˢ,
	Package: "gles",
	Name:    "GLvoidˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassGLvoidᵖ struct{}

func (*GLvoidᵖ) Class() binary.Class {
	return (*binaryClassGLvoidᵖ)(nil)
}
func doEncodeGLvoidᵖ(e binary.Encoder, o *GLvoidᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGLvoidᵖ(d binary.Decoder, o *GLvoidᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGLvoidᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGLvoidᵖ) ID() binary.ID      { return binaryIDGLvoidᵖ }
func (*binaryClassGLvoidᵖ) New() binary.Object { return &GLvoidᵖ{} }
func (*binaryClassGLvoidᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGLvoidᵖ(e, obj.(*GLvoidᵖ))
}
func (*binaryClassGLvoidᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GLvoidᵖ{}
	return obj, doDecodeGLvoidᵖ(d, obj)
}
func (*binaryClassGLvoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGLvoidᵖ(d, obj.(*GLvoidᵖ))
}
func (*binaryClassGLvoidᵖ) Skip(d binary.Decoder) error { return doSkipGLvoidᵖ(d) }
func (*binaryClassGLvoidᵖ) Schema() *schema.Class       { return schemaGLvoidᵖ }

var schemaGLvoidᵖ = &schema.Class{
	TypeID:  binaryIDGLvoidᵖ,
	Package: "gles",
	Name:    "GLvoidᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlActiveShaderProgram struct{}

func (*GlActiveShaderProgram) Class() binary.Class {
	return (*binaryClassGlActiveShaderProgram)(nil)
}
func doEncodeGlActiveShaderProgram(e binary.Encoder, o *GlActiveShaderProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlActiveShaderProgram(d binary.Decoder, o *GlActiveShaderProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlActiveShaderProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlActiveShaderProgram) ID() binary.ID      { return binaryIDGlActiveShaderProgram }
func (*binaryClassGlActiveShaderProgram) New() binary.Object { return &GlActiveShaderProgram{} }
func (*binaryClassGlActiveShaderProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlActiveShaderProgram(e, obj.(*GlActiveShaderProgram))
}
func (*binaryClassGlActiveShaderProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlActiveShaderProgram{}
	return obj, doDecodeGlActiveShaderProgram(d, obj)
}
func (*binaryClassGlActiveShaderProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlActiveShaderProgram(d, obj.(*GlActiveShaderProgram))
}
func (*binaryClassGlActiveShaderProgram) Skip(d binary.Decoder) error {
	return doSkipGlActiveShaderProgram(d)
}
func (*binaryClassGlActiveShaderProgram) Schema() *schema.Class { return schemaGlActiveShaderProgram }

var schemaGlActiveShaderProgram = &schema.Class{
	TypeID:  binaryIDGlActiveShaderProgram,
	Package: "gles",
	Name:    "GlActiveShaderProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlActiveShaderProgramEXT struct{}

func (*GlActiveShaderProgramEXT) Class() binary.Class {
	return (*binaryClassGlActiveShaderProgramEXT)(nil)
}
func doEncodeGlActiveShaderProgramEXT(e binary.Encoder, o *GlActiveShaderProgramEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlActiveShaderProgramEXT(d binary.Decoder, o *GlActiveShaderProgramEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlActiveShaderProgramEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlActiveShaderProgramEXT) ID() binary.ID      { return binaryIDGlActiveShaderProgramEXT }
func (*binaryClassGlActiveShaderProgramEXT) New() binary.Object { return &GlActiveShaderProgramEXT{} }
func (*binaryClassGlActiveShaderProgramEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlActiveShaderProgramEXT(e, obj.(*GlActiveShaderProgramEXT))
}
func (*binaryClassGlActiveShaderProgramEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlActiveShaderProgramEXT{}
	return obj, doDecodeGlActiveShaderProgramEXT(d, obj)
}
func (*binaryClassGlActiveShaderProgramEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlActiveShaderProgramEXT(d, obj.(*GlActiveShaderProgramEXT))
}
func (*binaryClassGlActiveShaderProgramEXT) Skip(d binary.Decoder) error {
	return doSkipGlActiveShaderProgramEXT(d)
}
func (*binaryClassGlActiveShaderProgramEXT) Schema() *schema.Class {
	return schemaGlActiveShaderProgramEXT
}

var schemaGlActiveShaderProgramEXT = &schema.Class{
	TypeID:  binaryIDGlActiveShaderProgramEXT,
	Package: "gles",
	Name:    "GlActiveShaderProgramEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlActiveTexture struct{}

func (*GlActiveTexture) Class() binary.Class {
	return (*binaryClassGlActiveTexture)(nil)
}
func doEncodeGlActiveTexture(e binary.Encoder, o *GlActiveTexture) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Unit)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlActiveTexture(d binary.Decoder, o *GlActiveTexture) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Unit = GLenum(obj)
	}
	return nil
}
func doSkipGlActiveTexture(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlActiveTexture) ID() binary.ID      { return binaryIDGlActiveTexture }
func (*binaryClassGlActiveTexture) New() binary.Object { return &GlActiveTexture{} }
func (*binaryClassGlActiveTexture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlActiveTexture(e, obj.(*GlActiveTexture))
}
func (*binaryClassGlActiveTexture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlActiveTexture{}
	return obj, doDecodeGlActiveTexture(d, obj)
}
func (*binaryClassGlActiveTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlActiveTexture(d, obj.(*GlActiveTexture))
}
func (*binaryClassGlActiveTexture) Skip(d binary.Decoder) error { return doSkipGlActiveTexture(d) }
func (*binaryClassGlActiveTexture) Schema() *schema.Class       { return schemaGlActiveTexture }

var schemaGlActiveTexture = &schema.Class{
	TypeID:  binaryIDGlActiveTexture,
	Package: "gles",
	Name:    "GlActiveTexture",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Unit", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlAlphaFuncQCOM struct{}

func (*GlAlphaFuncQCOM) Class() binary.Class {
	return (*binaryClassGlAlphaFuncQCOM)(nil)
}
func doEncodeGlAlphaFuncQCOM(e binary.Encoder, o *GlAlphaFuncQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Func)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Ref)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlAlphaFuncQCOM(d binary.Decoder, o *GlAlphaFuncQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Func = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Ref = GLclampf(obj)
	}
	return nil
}
func doSkipGlAlphaFuncQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlAlphaFuncQCOM) ID() binary.ID      { return binaryIDGlAlphaFuncQCOM }
func (*binaryClassGlAlphaFuncQCOM) New() binary.Object { return &GlAlphaFuncQCOM{} }
func (*binaryClassGlAlphaFuncQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlAlphaFuncQCOM(e, obj.(*GlAlphaFuncQCOM))
}
func (*binaryClassGlAlphaFuncQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlAlphaFuncQCOM{}
	return obj, doDecodeGlAlphaFuncQCOM(d, obj)
}
func (*binaryClassGlAlphaFuncQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlAlphaFuncQCOM(d, obj.(*GlAlphaFuncQCOM))
}
func (*binaryClassGlAlphaFuncQCOM) Skip(d binary.Decoder) error { return doSkipGlAlphaFuncQCOM(d) }
func (*binaryClassGlAlphaFuncQCOM) Schema() *schema.Class       { return schemaGlAlphaFuncQCOM }

var schemaGlAlphaFuncQCOM = &schema.Class{
	TypeID:  binaryIDGlAlphaFuncQCOM,
	Package: "gles",
	Name:    "GlAlphaFuncQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Func", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Ref", Type: &schema.Primitive{Name: "GLclampf", Method: schema.Float32}},
	},
}

type binaryClassGlAttachShader struct{}

func (*GlAttachShader) Class() binary.Class {
	return (*binaryClassGlAttachShader)(nil)
}
func doEncodeGlAttachShader(e binary.Encoder, o *GlAttachShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlAttachShader(d binary.Decoder, o *GlAttachShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	return nil
}
func doSkipGlAttachShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlAttachShader) ID() binary.ID      { return binaryIDGlAttachShader }
func (*binaryClassGlAttachShader) New() binary.Object { return &GlAttachShader{} }
func (*binaryClassGlAttachShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlAttachShader(e, obj.(*GlAttachShader))
}
func (*binaryClassGlAttachShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlAttachShader{}
	return obj, doDecodeGlAttachShader(d, obj)
}
func (*binaryClassGlAttachShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlAttachShader(d, obj.(*GlAttachShader))
}
func (*binaryClassGlAttachShader) Skip(d binary.Decoder) error { return doSkipGlAttachShader(d) }
func (*binaryClassGlAttachShader) Schema() *schema.Class       { return schemaGlAttachShader }

var schemaGlAttachShader = &schema.Class{
	TypeID:  binaryIDGlAttachShader,
	Package: "gles",
	Name:    "GlAttachShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginConditionalRenderNV struct{}

func (*GlBeginConditionalRenderNV) Class() binary.Class {
	return (*binaryClassGlBeginConditionalRenderNV)(nil)
}
func doEncodeGlBeginConditionalRenderNV(e binary.Encoder, o *GlBeginConditionalRenderNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Id)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginConditionalRenderNV(d binary.Decoder, o *GlBeginConditionalRenderNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlBeginConditionalRenderNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginConditionalRenderNV) ID() binary.ID {
	return binaryIDGlBeginConditionalRenderNV
}
func (*binaryClassGlBeginConditionalRenderNV) New() binary.Object {
	return &GlBeginConditionalRenderNV{}
}
func (*binaryClassGlBeginConditionalRenderNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginConditionalRenderNV(e, obj.(*GlBeginConditionalRenderNV))
}
func (*binaryClassGlBeginConditionalRenderNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginConditionalRenderNV{}
	return obj, doDecodeGlBeginConditionalRenderNV(d, obj)
}
func (*binaryClassGlBeginConditionalRenderNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginConditionalRenderNV(d, obj.(*GlBeginConditionalRenderNV))
}
func (*binaryClassGlBeginConditionalRenderNV) Skip(d binary.Decoder) error {
	return doSkipGlBeginConditionalRenderNV(d)
}
func (*binaryClassGlBeginConditionalRenderNV) Schema() *schema.Class {
	return schemaGlBeginConditionalRenderNV
}

var schemaGlBeginConditionalRenderNV = &schema.Class{
	TypeID:  binaryIDGlBeginConditionalRenderNV,
	Package: "gles",
	Name:    "GlBeginConditionalRenderNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Id", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginPerfMonitorAMD struct{}

func (*GlBeginPerfMonitorAMD) Class() binary.Class {
	return (*binaryClassGlBeginPerfMonitorAMD)(nil)
}
func doEncodeGlBeginPerfMonitorAMD(e binary.Encoder, o *GlBeginPerfMonitorAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Monitor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginPerfMonitorAMD(d binary.Decoder, o *GlBeginPerfMonitorAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Monitor = GLuint(obj)
	}
	return nil
}
func doSkipGlBeginPerfMonitorAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginPerfMonitorAMD) ID() binary.ID      { return binaryIDGlBeginPerfMonitorAMD }
func (*binaryClassGlBeginPerfMonitorAMD) New() binary.Object { return &GlBeginPerfMonitorAMD{} }
func (*binaryClassGlBeginPerfMonitorAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginPerfMonitorAMD(e, obj.(*GlBeginPerfMonitorAMD))
}
func (*binaryClassGlBeginPerfMonitorAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginPerfMonitorAMD{}
	return obj, doDecodeGlBeginPerfMonitorAMD(d, obj)
}
func (*binaryClassGlBeginPerfMonitorAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginPerfMonitorAMD(d, obj.(*GlBeginPerfMonitorAMD))
}
func (*binaryClassGlBeginPerfMonitorAMD) Skip(d binary.Decoder) error {
	return doSkipGlBeginPerfMonitorAMD(d)
}
func (*binaryClassGlBeginPerfMonitorAMD) Schema() *schema.Class { return schemaGlBeginPerfMonitorAMD }

var schemaGlBeginPerfMonitorAMD = &schema.Class{
	TypeID:  binaryIDGlBeginPerfMonitorAMD,
	Package: "gles",
	Name:    "GlBeginPerfMonitorAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Monitor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginPerfQueryINTEL struct{}

func (*GlBeginPerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlBeginPerfQueryINTEL)(nil)
}
func doEncodeGlBeginPerfQueryINTEL(e binary.Encoder, o *GlBeginPerfQueryINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryHandle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginPerfQueryINTEL(d binary.Decoder, o *GlBeginPerfQueryINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryHandle = GLuint(obj)
	}
	return nil
}
func doSkipGlBeginPerfQueryINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginPerfQueryINTEL) ID() binary.ID      { return binaryIDGlBeginPerfQueryINTEL }
func (*binaryClassGlBeginPerfQueryINTEL) New() binary.Object { return &GlBeginPerfQueryINTEL{} }
func (*binaryClassGlBeginPerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginPerfQueryINTEL(e, obj.(*GlBeginPerfQueryINTEL))
}
func (*binaryClassGlBeginPerfQueryINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginPerfQueryINTEL{}
	return obj, doDecodeGlBeginPerfQueryINTEL(d, obj)
}
func (*binaryClassGlBeginPerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginPerfQueryINTEL(d, obj.(*GlBeginPerfQueryINTEL))
}
func (*binaryClassGlBeginPerfQueryINTEL) Skip(d binary.Decoder) error {
	return doSkipGlBeginPerfQueryINTEL(d)
}
func (*binaryClassGlBeginPerfQueryINTEL) Schema() *schema.Class { return schemaGlBeginPerfQueryINTEL }

var schemaGlBeginPerfQueryINTEL = &schema.Class{
	TypeID:  binaryIDGlBeginPerfQueryINTEL,
	Package: "gles",
	Name:    "GlBeginPerfQueryINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryHandle", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginQuery struct{}

func (*GlBeginQuery) Class() binary.Class {
	return (*binaryClassGlBeginQuery)(nil)
}
func doEncodeGlBeginQuery(e binary.Encoder, o *GlBeginQuery) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginQuery(d binary.Decoder, o *GlBeginQuery) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	return nil
}
func doSkipGlBeginQuery(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginQuery) ID() binary.ID      { return binaryIDGlBeginQuery }
func (*binaryClassGlBeginQuery) New() binary.Object { return &GlBeginQuery{} }
func (*binaryClassGlBeginQuery) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginQuery(e, obj.(*GlBeginQuery))
}
func (*binaryClassGlBeginQuery) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginQuery{}
	return obj, doDecodeGlBeginQuery(d, obj)
}
func (*binaryClassGlBeginQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginQuery(d, obj.(*GlBeginQuery))
}
func (*binaryClassGlBeginQuery) Skip(d binary.Decoder) error { return doSkipGlBeginQuery(d) }
func (*binaryClassGlBeginQuery) Schema() *schema.Class       { return schemaGlBeginQuery }

var schemaGlBeginQuery = &schema.Class{
	TypeID:  binaryIDGlBeginQuery,
	Package: "gles",
	Name:    "GlBeginQuery",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginQueryEXT struct{}

func (*GlBeginQueryEXT) Class() binary.Class {
	return (*binaryClassGlBeginQueryEXT)(nil)
}
func doEncodeGlBeginQueryEXT(e binary.Encoder, o *GlBeginQueryEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginQueryEXT(d binary.Decoder, o *GlBeginQueryEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	return nil
}
func doSkipGlBeginQueryEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginQueryEXT) ID() binary.ID      { return binaryIDGlBeginQueryEXT }
func (*binaryClassGlBeginQueryEXT) New() binary.Object { return &GlBeginQueryEXT{} }
func (*binaryClassGlBeginQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginQueryEXT(e, obj.(*GlBeginQueryEXT))
}
func (*binaryClassGlBeginQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginQueryEXT{}
	return obj, doDecodeGlBeginQueryEXT(d, obj)
}
func (*binaryClassGlBeginQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginQueryEXT(d, obj.(*GlBeginQueryEXT))
}
func (*binaryClassGlBeginQueryEXT) Skip(d binary.Decoder) error { return doSkipGlBeginQueryEXT(d) }
func (*binaryClassGlBeginQueryEXT) Schema() *schema.Class       { return schemaGlBeginQueryEXT }

var schemaGlBeginQueryEXT = &schema.Class{
	TypeID:  binaryIDGlBeginQueryEXT,
	Package: "gles",
	Name:    "GlBeginQueryEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
	},
}

type binaryClassGlBeginTransformFeedback struct{}

func (*GlBeginTransformFeedback) Class() binary.Class {
	return (*binaryClassGlBeginTransformFeedback)(nil)
}
func doEncodeGlBeginTransformFeedback(e binary.Encoder, o *GlBeginTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PrimitiveMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBeginTransformFeedback(d binary.Decoder, o *GlBeginTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PrimitiveMode = GLenum(obj)
	}
	return nil
}
func doSkipGlBeginTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBeginTransformFeedback) ID() binary.ID      { return binaryIDGlBeginTransformFeedback }
func (*binaryClassGlBeginTransformFeedback) New() binary.Object { return &GlBeginTransformFeedback{} }
func (*binaryClassGlBeginTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBeginTransformFeedback(e, obj.(*GlBeginTransformFeedback))
}
func (*binaryClassGlBeginTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBeginTransformFeedback{}
	return obj, doDecodeGlBeginTransformFeedback(d, obj)
}
func (*binaryClassGlBeginTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBeginTransformFeedback(d, obj.(*GlBeginTransformFeedback))
}
func (*binaryClassGlBeginTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlBeginTransformFeedback(d)
}
func (*binaryClassGlBeginTransformFeedback) Schema() *schema.Class {
	return schemaGlBeginTransformFeedback
}

var schemaGlBeginTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlBeginTransformFeedback,
	Package: "gles",
	Name:    "GlBeginTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "PrimitiveMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBindAttribLocation struct{}

func (*GlBindAttribLocation) Class() binary.Class {
	return (*binaryClassGlBindAttribLocation)(nil)
}
func doEncodeGlBindAttribLocation(e binary.Encoder, o *GlBindAttribLocation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.String(o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindAttribLocation(d binary.Decoder, o *GlBindAttribLocation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	return nil
}
func doSkipGlBindAttribLocation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindAttribLocation) ID() binary.ID      { return binaryIDGlBindAttribLocation }
func (*binaryClassGlBindAttribLocation) New() binary.Object { return &GlBindAttribLocation{} }
func (*binaryClassGlBindAttribLocation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindAttribLocation(e, obj.(*GlBindAttribLocation))
}
func (*binaryClassGlBindAttribLocation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindAttribLocation{}
	return obj, doDecodeGlBindAttribLocation(d, obj)
}
func (*binaryClassGlBindAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindAttribLocation(d, obj.(*GlBindAttribLocation))
}
func (*binaryClassGlBindAttribLocation) Skip(d binary.Decoder) error {
	return doSkipGlBindAttribLocation(d)
}
func (*binaryClassGlBindAttribLocation) Schema() *schema.Class { return schemaGlBindAttribLocation }

var schemaGlBindAttribLocation = &schema.Class{
	TypeID:  binaryIDGlBindAttribLocation,
	Package: "gles",
	Name:    "GlBindAttribLocation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassGlBindBuffer struct{}

func (*GlBindBuffer) Class() binary.Class {
	return (*binaryClassGlBindBuffer)(nil)
}
func doEncodeGlBindBuffer(e binary.Encoder, o *GlBindBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindBuffer(d binary.Decoder, o *GlBindBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	return nil
}
func doSkipGlBindBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindBuffer) ID() binary.ID      { return binaryIDGlBindBuffer }
func (*binaryClassGlBindBuffer) New() binary.Object { return &GlBindBuffer{} }
func (*binaryClassGlBindBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindBuffer(e, obj.(*GlBindBuffer))
}
func (*binaryClassGlBindBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindBuffer{}
	return obj, doDecodeGlBindBuffer(d, obj)
}
func (*binaryClassGlBindBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindBuffer(d, obj.(*GlBindBuffer))
}
func (*binaryClassGlBindBuffer) Skip(d binary.Decoder) error { return doSkipGlBindBuffer(d) }
func (*binaryClassGlBindBuffer) Schema() *schema.Class       { return schemaGlBindBuffer }

var schemaGlBindBuffer = &schema.Class{
	TypeID:  binaryIDGlBindBuffer,
	Package: "gles",
	Name:    "GlBindBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindBufferBase struct{}

func (*GlBindBufferBase) Class() binary.Class {
	return (*binaryClassGlBindBufferBase)(nil)
}
func doEncodeGlBindBufferBase(e binary.Encoder, o *GlBindBufferBase) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindBufferBase(d binary.Decoder, o *GlBindBufferBase) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	return nil
}
func doSkipGlBindBufferBase(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindBufferBase) ID() binary.ID      { return binaryIDGlBindBufferBase }
func (*binaryClassGlBindBufferBase) New() binary.Object { return &GlBindBufferBase{} }
func (*binaryClassGlBindBufferBase) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindBufferBase(e, obj.(*GlBindBufferBase))
}
func (*binaryClassGlBindBufferBase) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindBufferBase{}
	return obj, doDecodeGlBindBufferBase(d, obj)
}
func (*binaryClassGlBindBufferBase) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindBufferBase(d, obj.(*GlBindBufferBase))
}
func (*binaryClassGlBindBufferBase) Skip(d binary.Decoder) error { return doSkipGlBindBufferBase(d) }
func (*binaryClassGlBindBufferBase) Schema() *schema.Class       { return schemaGlBindBufferBase }

var schemaGlBindBufferBase = &schema.Class{
	TypeID:  binaryIDGlBindBufferBase,
	Package: "gles",
	Name:    "GlBindBufferBase",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindBufferRange struct{}

func (*GlBindBufferRange) Class() binary.Class {
	return (*binaryClassGlBindBufferRange)(nil)
}
func doEncodeGlBindBufferRange(e binary.Encoder, o *GlBindBufferRange) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindBufferRange(d binary.Decoder, o *GlBindBufferRange) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlBindBufferRange(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindBufferRange) ID() binary.ID      { return binaryIDGlBindBufferRange }
func (*binaryClassGlBindBufferRange) New() binary.Object { return &GlBindBufferRange{} }
func (*binaryClassGlBindBufferRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindBufferRange(e, obj.(*GlBindBufferRange))
}
func (*binaryClassGlBindBufferRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindBufferRange{}
	return obj, doDecodeGlBindBufferRange(d, obj)
}
func (*binaryClassGlBindBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindBufferRange(d, obj.(*GlBindBufferRange))
}
func (*binaryClassGlBindBufferRange) Skip(d binary.Decoder) error { return doSkipGlBindBufferRange(d) }
func (*binaryClassGlBindBufferRange) Schema() *schema.Class       { return schemaGlBindBufferRange }

var schemaGlBindBufferRange = &schema.Class{
	TypeID:  binaryIDGlBindBufferRange,
	Package: "gles",
	Name:    "GlBindBufferRange",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlBindFramebuffer struct{}

func (*GlBindFramebuffer) Class() binary.Class {
	return (*binaryClassGlBindFramebuffer)(nil)
}
func doEncodeGlBindFramebuffer(e binary.Encoder, o *GlBindFramebuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Framebuffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindFramebuffer(d binary.Decoder, o *GlBindFramebuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Framebuffer = FramebufferId(obj)
	}
	return nil
}
func doSkipGlBindFramebuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindFramebuffer) ID() binary.ID      { return binaryIDGlBindFramebuffer }
func (*binaryClassGlBindFramebuffer) New() binary.Object { return &GlBindFramebuffer{} }
func (*binaryClassGlBindFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindFramebuffer(e, obj.(*GlBindFramebuffer))
}
func (*binaryClassGlBindFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindFramebuffer{}
	return obj, doDecodeGlBindFramebuffer(d, obj)
}
func (*binaryClassGlBindFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindFramebuffer(d, obj.(*GlBindFramebuffer))
}
func (*binaryClassGlBindFramebuffer) Skip(d binary.Decoder) error { return doSkipGlBindFramebuffer(d) }
func (*binaryClassGlBindFramebuffer) Schema() *schema.Class       { return schemaGlBindFramebuffer }

var schemaGlBindFramebuffer = &schema.Class{
	TypeID:  binaryIDGlBindFramebuffer,
	Package: "gles",
	Name:    "GlBindFramebuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindImageTexture struct{}

func (*GlBindImageTexture) Class() binary.Class {
	return (*binaryClassGlBindImageTexture)(nil)
}
func doEncodeGlBindImageTexture(e binary.Encoder, o *GlBindImageTexture) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Unit)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Layered)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Layer)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Access)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindImageTexture(d binary.Decoder, o *GlBindImageTexture) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Unit = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Layered = GLboolean(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Layer = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Access = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	return nil
}
func doSkipGlBindImageTexture(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindImageTexture) ID() binary.ID      { return binaryIDGlBindImageTexture }
func (*binaryClassGlBindImageTexture) New() binary.Object { return &GlBindImageTexture{} }
func (*binaryClassGlBindImageTexture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindImageTexture(e, obj.(*GlBindImageTexture))
}
func (*binaryClassGlBindImageTexture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindImageTexture{}
	return obj, doDecodeGlBindImageTexture(d, obj)
}
func (*binaryClassGlBindImageTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindImageTexture(d, obj.(*GlBindImageTexture))
}
func (*binaryClassGlBindImageTexture) Skip(d binary.Decoder) error { return doSkipGlBindImageTexture(d) }
func (*binaryClassGlBindImageTexture) Schema() *schema.Class       { return schemaGlBindImageTexture }

var schemaGlBindImageTexture = &schema.Class{
	TypeID:  binaryIDGlBindImageTexture,
	Package: "gles",
	Name:    "GlBindImageTexture",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Unit", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Layered", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Layer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Access", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBindProgramPipeline struct{}

func (*GlBindProgramPipeline) Class() binary.Class {
	return (*binaryClassGlBindProgramPipeline)(nil)
}
func doEncodeGlBindProgramPipeline(e binary.Encoder, o *GlBindProgramPipeline) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindProgramPipeline(d binary.Decoder, o *GlBindProgramPipeline) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	return nil
}
func doSkipGlBindProgramPipeline(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindProgramPipeline) ID() binary.ID      { return binaryIDGlBindProgramPipeline }
func (*binaryClassGlBindProgramPipeline) New() binary.Object { return &GlBindProgramPipeline{} }
func (*binaryClassGlBindProgramPipeline) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindProgramPipeline(e, obj.(*GlBindProgramPipeline))
}
func (*binaryClassGlBindProgramPipeline) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindProgramPipeline{}
	return obj, doDecodeGlBindProgramPipeline(d, obj)
}
func (*binaryClassGlBindProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindProgramPipeline(d, obj.(*GlBindProgramPipeline))
}
func (*binaryClassGlBindProgramPipeline) Skip(d binary.Decoder) error {
	return doSkipGlBindProgramPipeline(d)
}
func (*binaryClassGlBindProgramPipeline) Schema() *schema.Class { return schemaGlBindProgramPipeline }

var schemaGlBindProgramPipeline = &schema.Class{
	TypeID:  binaryIDGlBindProgramPipeline,
	Package: "gles",
	Name:    "GlBindProgramPipeline",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindProgramPipelineEXT struct{}

func (*GlBindProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlBindProgramPipelineEXT)(nil)
}
func doEncodeGlBindProgramPipelineEXT(e binary.Encoder, o *GlBindProgramPipelineEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindProgramPipelineEXT(d binary.Decoder, o *GlBindProgramPipelineEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	return nil
}
func doSkipGlBindProgramPipelineEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindProgramPipelineEXT) ID() binary.ID      { return binaryIDGlBindProgramPipelineEXT }
func (*binaryClassGlBindProgramPipelineEXT) New() binary.Object { return &GlBindProgramPipelineEXT{} }
func (*binaryClassGlBindProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindProgramPipelineEXT(e, obj.(*GlBindProgramPipelineEXT))
}
func (*binaryClassGlBindProgramPipelineEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindProgramPipelineEXT{}
	return obj, doDecodeGlBindProgramPipelineEXT(d, obj)
}
func (*binaryClassGlBindProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindProgramPipelineEXT(d, obj.(*GlBindProgramPipelineEXT))
}
func (*binaryClassGlBindProgramPipelineEXT) Skip(d binary.Decoder) error {
	return doSkipGlBindProgramPipelineEXT(d)
}
func (*binaryClassGlBindProgramPipelineEXT) Schema() *schema.Class {
	return schemaGlBindProgramPipelineEXT
}

var schemaGlBindProgramPipelineEXT = &schema.Class{
	TypeID:  binaryIDGlBindProgramPipelineEXT,
	Package: "gles",
	Name:    "GlBindProgramPipelineEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindRenderbuffer struct{}

func (*GlBindRenderbuffer) Class() binary.Class {
	return (*binaryClassGlBindRenderbuffer)(nil)
}
func doEncodeGlBindRenderbuffer(e binary.Encoder, o *GlBindRenderbuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindRenderbuffer(d binary.Decoder, o *GlBindRenderbuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Renderbuffer = RenderbufferId(obj)
	}
	return nil
}
func doSkipGlBindRenderbuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindRenderbuffer) ID() binary.ID      { return binaryIDGlBindRenderbuffer }
func (*binaryClassGlBindRenderbuffer) New() binary.Object { return &GlBindRenderbuffer{} }
func (*binaryClassGlBindRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindRenderbuffer(e, obj.(*GlBindRenderbuffer))
}
func (*binaryClassGlBindRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindRenderbuffer{}
	return obj, doDecodeGlBindRenderbuffer(d, obj)
}
func (*binaryClassGlBindRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindRenderbuffer(d, obj.(*GlBindRenderbuffer))
}
func (*binaryClassGlBindRenderbuffer) Skip(d binary.Decoder) error { return doSkipGlBindRenderbuffer(d) }
func (*binaryClassGlBindRenderbuffer) Schema() *schema.Class       { return schemaGlBindRenderbuffer }

var schemaGlBindRenderbuffer = &schema.Class{
	TypeID:  binaryIDGlBindRenderbuffer,
	Package: "gles",
	Name:    "GlBindRenderbuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindSampler struct{}

func (*GlBindSampler) Class() binary.Class {
	return (*binaryClassGlBindSampler)(nil)
}
func doEncodeGlBindSampler(e binary.Encoder, o *GlBindSampler) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Unit)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindSampler(d binary.Decoder, o *GlBindSampler) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Unit = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	return nil
}
func doSkipGlBindSampler(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindSampler) ID() binary.ID      { return binaryIDGlBindSampler }
func (*binaryClassGlBindSampler) New() binary.Object { return &GlBindSampler{} }
func (*binaryClassGlBindSampler) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindSampler(e, obj.(*GlBindSampler))
}
func (*binaryClassGlBindSampler) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindSampler{}
	return obj, doDecodeGlBindSampler(d, obj)
}
func (*binaryClassGlBindSampler) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindSampler(d, obj.(*GlBindSampler))
}
func (*binaryClassGlBindSampler) Skip(d binary.Decoder) error { return doSkipGlBindSampler(d) }
func (*binaryClassGlBindSampler) Schema() *schema.Class       { return schemaGlBindSampler }

var schemaGlBindSampler = &schema.Class{
	TypeID:  binaryIDGlBindSampler,
	Package: "gles",
	Name:    "GlBindSampler",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Unit", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindTexture struct{}

func (*GlBindTexture) Class() binary.Class {
	return (*binaryClassGlBindTexture)(nil)
}
func doEncodeGlBindTexture(e binary.Encoder, o *GlBindTexture) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindTexture(d binary.Decoder, o *GlBindTexture) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	return nil
}
func doSkipGlBindTexture(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindTexture) ID() binary.ID      { return binaryIDGlBindTexture }
func (*binaryClassGlBindTexture) New() binary.Object { return &GlBindTexture{} }
func (*binaryClassGlBindTexture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindTexture(e, obj.(*GlBindTexture))
}
func (*binaryClassGlBindTexture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindTexture{}
	return obj, doDecodeGlBindTexture(d, obj)
}
func (*binaryClassGlBindTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindTexture(d, obj.(*GlBindTexture))
}
func (*binaryClassGlBindTexture) Skip(d binary.Decoder) error { return doSkipGlBindTexture(d) }
func (*binaryClassGlBindTexture) Schema() *schema.Class       { return schemaGlBindTexture }

var schemaGlBindTexture = &schema.Class{
	TypeID:  binaryIDGlBindTexture,
	Package: "gles",
	Name:    "GlBindTexture",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindTransformFeedback struct{}

func (*GlBindTransformFeedback) Class() binary.Class {
	return (*binaryClassGlBindTransformFeedback)(nil)
}
func doEncodeGlBindTransformFeedback(e binary.Encoder, o *GlBindTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Id)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindTransformFeedback(d binary.Decoder, o *GlBindTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = TransformFeedbackId(obj)
	}
	return nil
}
func doSkipGlBindTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindTransformFeedback) ID() binary.ID      { return binaryIDGlBindTransformFeedback }
func (*binaryClassGlBindTransformFeedback) New() binary.Object { return &GlBindTransformFeedback{} }
func (*binaryClassGlBindTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindTransformFeedback(e, obj.(*GlBindTransformFeedback))
}
func (*binaryClassGlBindTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindTransformFeedback{}
	return obj, doDecodeGlBindTransformFeedback(d, obj)
}
func (*binaryClassGlBindTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindTransformFeedback(d, obj.(*GlBindTransformFeedback))
}
func (*binaryClassGlBindTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlBindTransformFeedback(d)
}
func (*binaryClassGlBindTransformFeedback) Schema() *schema.Class {
	return schemaGlBindTransformFeedback
}

var schemaGlBindTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlBindTransformFeedback,
	Package: "gles",
	Name:    "GlBindTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Id", Type: &schema.Primitive{Name: "TransformFeedbackId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindVertexArray struct{}

func (*GlBindVertexArray) Class() binary.Class {
	return (*binaryClassGlBindVertexArray)(nil)
}
func doEncodeGlBindVertexArray(e binary.Encoder, o *GlBindVertexArray) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Array)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindVertexArray(d binary.Decoder, o *GlBindVertexArray) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Array = VertexArrayId(obj)
	}
	return nil
}
func doSkipGlBindVertexArray(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindVertexArray) ID() binary.ID      { return binaryIDGlBindVertexArray }
func (*binaryClassGlBindVertexArray) New() binary.Object { return &GlBindVertexArray{} }
func (*binaryClassGlBindVertexArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindVertexArray(e, obj.(*GlBindVertexArray))
}
func (*binaryClassGlBindVertexArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindVertexArray{}
	return obj, doDecodeGlBindVertexArray(d, obj)
}
func (*binaryClassGlBindVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindVertexArray(d, obj.(*GlBindVertexArray))
}
func (*binaryClassGlBindVertexArray) Skip(d binary.Decoder) error { return doSkipGlBindVertexArray(d) }
func (*binaryClassGlBindVertexArray) Schema() *schema.Class       { return schemaGlBindVertexArray }

var schemaGlBindVertexArray = &schema.Class{
	TypeID:  binaryIDGlBindVertexArray,
	Package: "gles",
	Name:    "GlBindVertexArray",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindVertexArrayOES struct{}

func (*GlBindVertexArrayOES) Class() binary.Class {
	return (*binaryClassGlBindVertexArrayOES)(nil)
}
func doEncodeGlBindVertexArrayOES(e binary.Encoder, o *GlBindVertexArrayOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Array)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindVertexArrayOES(d binary.Decoder, o *GlBindVertexArrayOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Array = VertexArrayId(obj)
	}
	return nil
}
func doSkipGlBindVertexArrayOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindVertexArrayOES) ID() binary.ID      { return binaryIDGlBindVertexArrayOES }
func (*binaryClassGlBindVertexArrayOES) New() binary.Object { return &GlBindVertexArrayOES{} }
func (*binaryClassGlBindVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindVertexArrayOES(e, obj.(*GlBindVertexArrayOES))
}
func (*binaryClassGlBindVertexArrayOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindVertexArrayOES{}
	return obj, doDecodeGlBindVertexArrayOES(d, obj)
}
func (*binaryClassGlBindVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindVertexArrayOES(d, obj.(*GlBindVertexArrayOES))
}
func (*binaryClassGlBindVertexArrayOES) Skip(d binary.Decoder) error {
	return doSkipGlBindVertexArrayOES(d)
}
func (*binaryClassGlBindVertexArrayOES) Schema() *schema.Class { return schemaGlBindVertexArrayOES }

var schemaGlBindVertexArrayOES = &schema.Class{
	TypeID:  binaryIDGlBindVertexArrayOES,
	Package: "gles",
	Name:    "GlBindVertexArrayOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
	},
}

type binaryClassGlBindVertexBuffer struct{}

func (*GlBindVertexBuffer) Class() binary.Class {
	return (*binaryClassGlBindVertexBuffer)(nil)
}
func doEncodeGlBindVertexBuffer(e binary.Encoder, o *GlBindVertexBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Bindingindex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBindVertexBuffer(d binary.Decoder, o *GlBindVertexBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Bindingindex = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	return nil
}
func doSkipGlBindVertexBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBindVertexBuffer) ID() binary.ID      { return binaryIDGlBindVertexBuffer }
func (*binaryClassGlBindVertexBuffer) New() binary.Object { return &GlBindVertexBuffer{} }
func (*binaryClassGlBindVertexBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBindVertexBuffer(e, obj.(*GlBindVertexBuffer))
}
func (*binaryClassGlBindVertexBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBindVertexBuffer{}
	return obj, doDecodeGlBindVertexBuffer(d, obj)
}
func (*binaryClassGlBindVertexBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBindVertexBuffer(d, obj.(*GlBindVertexBuffer))
}
func (*binaryClassGlBindVertexBuffer) Skip(d binary.Decoder) error { return doSkipGlBindVertexBuffer(d) }
func (*binaryClassGlBindVertexBuffer) Schema() *schema.Class       { return schemaGlBindVertexBuffer }

var schemaGlBindVertexBuffer = &schema.Class{
	TypeID:  binaryIDGlBindVertexBuffer,
	Package: "gles",
	Name:    "GlBindVertexBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Bindingindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlBlendBarrierKHR struct{}

func (*GlBlendBarrierKHR) Class() binary.Class {
	return (*binaryClassGlBlendBarrierKHR)(nil)
}
func doEncodeGlBlendBarrierKHR(e binary.Encoder, o *GlBlendBarrierKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendBarrierKHR(d binary.Decoder, o *GlBlendBarrierKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlBlendBarrierKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendBarrierKHR) ID() binary.ID      { return binaryIDGlBlendBarrierKHR }
func (*binaryClassGlBlendBarrierKHR) New() binary.Object { return &GlBlendBarrierKHR{} }
func (*binaryClassGlBlendBarrierKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendBarrierKHR(e, obj.(*GlBlendBarrierKHR))
}
func (*binaryClassGlBlendBarrierKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendBarrierKHR{}
	return obj, doDecodeGlBlendBarrierKHR(d, obj)
}
func (*binaryClassGlBlendBarrierKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendBarrierKHR(d, obj.(*GlBlendBarrierKHR))
}
func (*binaryClassGlBlendBarrierKHR) Skip(d binary.Decoder) error { return doSkipGlBlendBarrierKHR(d) }
func (*binaryClassGlBlendBarrierKHR) Schema() *schema.Class       { return schemaGlBlendBarrierKHR }

var schemaGlBlendBarrierKHR = &schema.Class{
	TypeID:  binaryIDGlBlendBarrierKHR,
	Package: "gles",
	Name:    "GlBlendBarrierKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlBlendBarrierNV struct{}

func (*GlBlendBarrierNV) Class() binary.Class {
	return (*binaryClassGlBlendBarrierNV)(nil)
}
func doEncodeGlBlendBarrierNV(e binary.Encoder, o *GlBlendBarrierNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendBarrierNV(d binary.Decoder, o *GlBlendBarrierNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlBlendBarrierNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendBarrierNV) ID() binary.ID      { return binaryIDGlBlendBarrierNV }
func (*binaryClassGlBlendBarrierNV) New() binary.Object { return &GlBlendBarrierNV{} }
func (*binaryClassGlBlendBarrierNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendBarrierNV(e, obj.(*GlBlendBarrierNV))
}
func (*binaryClassGlBlendBarrierNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendBarrierNV{}
	return obj, doDecodeGlBlendBarrierNV(d, obj)
}
func (*binaryClassGlBlendBarrierNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendBarrierNV(d, obj.(*GlBlendBarrierNV))
}
func (*binaryClassGlBlendBarrierNV) Skip(d binary.Decoder) error { return doSkipGlBlendBarrierNV(d) }
func (*binaryClassGlBlendBarrierNV) Schema() *schema.Class       { return schemaGlBlendBarrierNV }

var schemaGlBlendBarrierNV = &schema.Class{
	TypeID:  binaryIDGlBlendBarrierNV,
	Package: "gles",
	Name:    "GlBlendBarrierNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlBlendColor struct{}

func (*GlBlendColor) Class() binary.Class {
	return (*binaryClassGlBlendColor)(nil)
}
func doEncodeGlBlendColor(e binary.Encoder, o *GlBlendColor) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Red)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Green)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Blue)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Alpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendColor(d binary.Decoder, o *GlBlendColor) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Red = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Green = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Blue = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Alpha = GLfloat(obj)
	}
	return nil
}
func doSkipGlBlendColor(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendColor) ID() binary.ID      { return binaryIDGlBlendColor }
func (*binaryClassGlBlendColor) New() binary.Object { return &GlBlendColor{} }
func (*binaryClassGlBlendColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendColor(e, obj.(*GlBlendColor))
}
func (*binaryClassGlBlendColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendColor{}
	return obj, doDecodeGlBlendColor(d, obj)
}
func (*binaryClassGlBlendColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendColor(d, obj.(*GlBlendColor))
}
func (*binaryClassGlBlendColor) Skip(d binary.Decoder) error { return doSkipGlBlendColor(d) }
func (*binaryClassGlBlendColor) Schema() *schema.Class       { return schemaGlBlendColor }

var schemaGlBlendColor = &schema.Class{
	TypeID:  binaryIDGlBlendColor,
	Package: "gles",
	Name:    "GlBlendColor",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Red", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Green", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Blue", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Alpha", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlBlendEquation struct{}

func (*GlBlendEquation) Class() binary.Class {
	return (*binaryClassGlBlendEquation)(nil)
}
func doEncodeGlBlendEquation(e binary.Encoder, o *GlBlendEquation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Equation)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquation(d binary.Decoder, o *GlBlendEquation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Equation = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquation) ID() binary.ID      { return binaryIDGlBlendEquation }
func (*binaryClassGlBlendEquation) New() binary.Object { return &GlBlendEquation{} }
func (*binaryClassGlBlendEquation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquation(e, obj.(*GlBlendEquation))
}
func (*binaryClassGlBlendEquation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquation{}
	return obj, doDecodeGlBlendEquation(d, obj)
}
func (*binaryClassGlBlendEquation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquation(d, obj.(*GlBlendEquation))
}
func (*binaryClassGlBlendEquation) Skip(d binary.Decoder) error { return doSkipGlBlendEquation(d) }
func (*binaryClassGlBlendEquation) Schema() *schema.Class       { return schemaGlBlendEquation }

var schemaGlBlendEquation = &schema.Class{
	TypeID:  binaryIDGlBlendEquation,
	Package: "gles",
	Name:    "GlBlendEquation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Equation", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendEquationSeparate struct{}

func (*GlBlendEquationSeparate) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparate)(nil)
}
func doEncodeGlBlendEquationSeparate(e binary.Encoder, o *GlBlendEquationSeparate) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Rgb)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Alpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquationSeparate(d binary.Decoder, o *GlBlendEquationSeparate) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Rgb = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Alpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquationSeparate(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquationSeparate) ID() binary.ID      { return binaryIDGlBlendEquationSeparate }
func (*binaryClassGlBlendEquationSeparate) New() binary.Object { return &GlBlendEquationSeparate{} }
func (*binaryClassGlBlendEquationSeparate) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquationSeparate(e, obj.(*GlBlendEquationSeparate))
}
func (*binaryClassGlBlendEquationSeparate) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquationSeparate{}
	return obj, doDecodeGlBlendEquationSeparate(d, obj)
}
func (*binaryClassGlBlendEquationSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquationSeparate(d, obj.(*GlBlendEquationSeparate))
}
func (*binaryClassGlBlendEquationSeparate) Skip(d binary.Decoder) error {
	return doSkipGlBlendEquationSeparate(d)
}
func (*binaryClassGlBlendEquationSeparate) Schema() *schema.Class {
	return schemaGlBlendEquationSeparate
}

var schemaGlBlendEquationSeparate = &schema.Class{
	TypeID:  binaryIDGlBlendEquationSeparate,
	Package: "gles",
	Name:    "GlBlendEquationSeparate",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Rgb", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Alpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendEquationSeparateiEXT struct{}

func (*GlBlendEquationSeparateiEXT) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparateiEXT)(nil)
}
func doEncodeGlBlendEquationSeparateiEXT(e binary.Encoder, o *GlBlendEquationSeparateiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ModeRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ModeAlpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquationSeparateiEXT(d binary.Decoder, o *GlBlendEquationSeparateiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ModeRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ModeAlpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquationSeparateiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquationSeparateiEXT) ID() binary.ID {
	return binaryIDGlBlendEquationSeparateiEXT
}
func (*binaryClassGlBlendEquationSeparateiEXT) New() binary.Object {
	return &GlBlendEquationSeparateiEXT{}
}
func (*binaryClassGlBlendEquationSeparateiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquationSeparateiEXT(e, obj.(*GlBlendEquationSeparateiEXT))
}
func (*binaryClassGlBlendEquationSeparateiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquationSeparateiEXT{}
	return obj, doDecodeGlBlendEquationSeparateiEXT(d, obj)
}
func (*binaryClassGlBlendEquationSeparateiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquationSeparateiEXT(d, obj.(*GlBlendEquationSeparateiEXT))
}
func (*binaryClassGlBlendEquationSeparateiEXT) Skip(d binary.Decoder) error {
	return doSkipGlBlendEquationSeparateiEXT(d)
}
func (*binaryClassGlBlendEquationSeparateiEXT) Schema() *schema.Class {
	return schemaGlBlendEquationSeparateiEXT
}

var schemaGlBlendEquationSeparateiEXT = &schema.Class{
	TypeID:  binaryIDGlBlendEquationSeparateiEXT,
	Package: "gles",
	Name:    "GlBlendEquationSeparateiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "ModeRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ModeAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendEquationSeparateiOES struct{}

func (*GlBlendEquationSeparateiOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationSeparateiOES)(nil)
}
func doEncodeGlBlendEquationSeparateiOES(e binary.Encoder, o *GlBlendEquationSeparateiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ModeRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ModeAlpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquationSeparateiOES(d binary.Decoder, o *GlBlendEquationSeparateiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ModeRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ModeAlpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquationSeparateiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquationSeparateiOES) ID() binary.ID {
	return binaryIDGlBlendEquationSeparateiOES
}
func (*binaryClassGlBlendEquationSeparateiOES) New() binary.Object {
	return &GlBlendEquationSeparateiOES{}
}
func (*binaryClassGlBlendEquationSeparateiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquationSeparateiOES(e, obj.(*GlBlendEquationSeparateiOES))
}
func (*binaryClassGlBlendEquationSeparateiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquationSeparateiOES{}
	return obj, doDecodeGlBlendEquationSeparateiOES(d, obj)
}
func (*binaryClassGlBlendEquationSeparateiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquationSeparateiOES(d, obj.(*GlBlendEquationSeparateiOES))
}
func (*binaryClassGlBlendEquationSeparateiOES) Skip(d binary.Decoder) error {
	return doSkipGlBlendEquationSeparateiOES(d)
}
func (*binaryClassGlBlendEquationSeparateiOES) Schema() *schema.Class {
	return schemaGlBlendEquationSeparateiOES
}

var schemaGlBlendEquationSeparateiOES = &schema.Class{
	TypeID:  binaryIDGlBlendEquationSeparateiOES,
	Package: "gles",
	Name:    "GlBlendEquationSeparateiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "ModeRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ModeAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendEquationiEXT struct{}

func (*GlBlendEquationiEXT) Class() binary.Class {
	return (*binaryClassGlBlendEquationiEXT)(nil)
}
func doEncodeGlBlendEquationiEXT(e binary.Encoder, o *GlBlendEquationiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquationiEXT(d binary.Decoder, o *GlBlendEquationiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquationiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquationiEXT) ID() binary.ID      { return binaryIDGlBlendEquationiEXT }
func (*binaryClassGlBlendEquationiEXT) New() binary.Object { return &GlBlendEquationiEXT{} }
func (*binaryClassGlBlendEquationiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquationiEXT(e, obj.(*GlBlendEquationiEXT))
}
func (*binaryClassGlBlendEquationiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquationiEXT{}
	return obj, doDecodeGlBlendEquationiEXT(d, obj)
}
func (*binaryClassGlBlendEquationiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquationiEXT(d, obj.(*GlBlendEquationiEXT))
}
func (*binaryClassGlBlendEquationiEXT) Skip(d binary.Decoder) error {
	return doSkipGlBlendEquationiEXT(d)
}
func (*binaryClassGlBlendEquationiEXT) Schema() *schema.Class { return schemaGlBlendEquationiEXT }

var schemaGlBlendEquationiEXT = &schema.Class{
	TypeID:  binaryIDGlBlendEquationiEXT,
	Package: "gles",
	Name:    "GlBlendEquationiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendEquationiOES struct{}

func (*GlBlendEquationiOES) Class() binary.Class {
	return (*binaryClassGlBlendEquationiOES)(nil)
}
func doEncodeGlBlendEquationiOES(e binary.Encoder, o *GlBlendEquationiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendEquationiOES(d binary.Decoder, o *GlBlendEquationiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendEquationiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendEquationiOES) ID() binary.ID      { return binaryIDGlBlendEquationiOES }
func (*binaryClassGlBlendEquationiOES) New() binary.Object { return &GlBlendEquationiOES{} }
func (*binaryClassGlBlendEquationiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendEquationiOES(e, obj.(*GlBlendEquationiOES))
}
func (*binaryClassGlBlendEquationiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendEquationiOES{}
	return obj, doDecodeGlBlendEquationiOES(d, obj)
}
func (*binaryClassGlBlendEquationiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendEquationiOES(d, obj.(*GlBlendEquationiOES))
}
func (*binaryClassGlBlendEquationiOES) Skip(d binary.Decoder) error {
	return doSkipGlBlendEquationiOES(d)
}
func (*binaryClassGlBlendEquationiOES) Schema() *schema.Class { return schemaGlBlendEquationiOES }

var schemaGlBlendEquationiOES = &schema.Class{
	TypeID:  binaryIDGlBlendEquationiOES,
	Package: "gles",
	Name:    "GlBlendEquationiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFunc struct{}

func (*GlBlendFunc) Class() binary.Class {
	return (*binaryClassGlBlendFunc)(nil)
}
func doEncodeGlBlendFunc(e binary.Encoder, o *GlBlendFunc) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcFactor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstFactor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFunc(d binary.Decoder, o *GlBlendFunc) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcFactor = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstFactor = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFunc(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFunc) ID() binary.ID      { return binaryIDGlBlendFunc }
func (*binaryClassGlBlendFunc) New() binary.Object { return &GlBlendFunc{} }
func (*binaryClassGlBlendFunc) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFunc(e, obj.(*GlBlendFunc))
}
func (*binaryClassGlBlendFunc) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFunc{}
	return obj, doDecodeGlBlendFunc(d, obj)
}
func (*binaryClassGlBlendFunc) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFunc(d, obj.(*GlBlendFunc))
}
func (*binaryClassGlBlendFunc) Skip(d binary.Decoder) error { return doSkipGlBlendFunc(d) }
func (*binaryClassGlBlendFunc) Schema() *schema.Class       { return schemaGlBlendFunc }

var schemaGlBlendFunc = &schema.Class{
	TypeID:  binaryIDGlBlendFunc,
	Package: "gles",
	Name:    "GlBlendFunc",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstFactor", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFuncSeparate struct{}

func (*GlBlendFuncSeparate) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparate)(nil)
}
func doEncodeGlBlendFuncSeparate(e binary.Encoder, o *GlBlendFuncSeparate) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcFactorRgb)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstFactorRgb)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcFactorAlpha)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstFactorAlpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFuncSeparate(d binary.Decoder, o *GlBlendFuncSeparate) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcFactorRgb = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstFactorRgb = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcFactorAlpha = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstFactorAlpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFuncSeparate(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFuncSeparate) ID() binary.ID      { return binaryIDGlBlendFuncSeparate }
func (*binaryClassGlBlendFuncSeparate) New() binary.Object { return &GlBlendFuncSeparate{} }
func (*binaryClassGlBlendFuncSeparate) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFuncSeparate(e, obj.(*GlBlendFuncSeparate))
}
func (*binaryClassGlBlendFuncSeparate) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFuncSeparate{}
	return obj, doDecodeGlBlendFuncSeparate(d, obj)
}
func (*binaryClassGlBlendFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFuncSeparate(d, obj.(*GlBlendFuncSeparate))
}
func (*binaryClassGlBlendFuncSeparate) Skip(d binary.Decoder) error {
	return doSkipGlBlendFuncSeparate(d)
}
func (*binaryClassGlBlendFuncSeparate) Schema() *schema.Class { return schemaGlBlendFuncSeparate }

var schemaGlBlendFuncSeparate = &schema.Class{
	TypeID:  binaryIDGlBlendFuncSeparate,
	Package: "gles",
	Name:    "GlBlendFuncSeparate",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcFactorRgb", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstFactorRgb", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcFactorAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstFactorAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFuncSeparateiEXT struct{}

func (*GlBlendFuncSeparateiEXT) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparateiEXT)(nil)
}
func doEncodeGlBlendFuncSeparateiEXT(e binary.Encoder, o *GlBlendFuncSeparateiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcAlpha)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstAlpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFuncSeparateiEXT(d binary.Decoder, o *GlBlendFuncSeparateiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcAlpha = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstAlpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFuncSeparateiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFuncSeparateiEXT) ID() binary.ID      { return binaryIDGlBlendFuncSeparateiEXT }
func (*binaryClassGlBlendFuncSeparateiEXT) New() binary.Object { return &GlBlendFuncSeparateiEXT{} }
func (*binaryClassGlBlendFuncSeparateiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFuncSeparateiEXT(e, obj.(*GlBlendFuncSeparateiEXT))
}
func (*binaryClassGlBlendFuncSeparateiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFuncSeparateiEXT{}
	return obj, doDecodeGlBlendFuncSeparateiEXT(d, obj)
}
func (*binaryClassGlBlendFuncSeparateiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFuncSeparateiEXT(d, obj.(*GlBlendFuncSeparateiEXT))
}
func (*binaryClassGlBlendFuncSeparateiEXT) Skip(d binary.Decoder) error {
	return doSkipGlBlendFuncSeparateiEXT(d)
}
func (*binaryClassGlBlendFuncSeparateiEXT) Schema() *schema.Class {
	return schemaGlBlendFuncSeparateiEXT
}

var schemaGlBlendFuncSeparateiEXT = &schema.Class{
	TypeID:  binaryIDGlBlendFuncSeparateiEXT,
	Package: "gles",
	Name:    "GlBlendFuncSeparateiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFuncSeparateiOES struct{}

func (*GlBlendFuncSeparateiOES) Class() binary.Class {
	return (*binaryClassGlBlendFuncSeparateiOES)(nil)
}
func doEncodeGlBlendFuncSeparateiOES(e binary.Encoder, o *GlBlendFuncSeparateiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstRGB)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcAlpha)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstAlpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFuncSeparateiOES(d binary.Decoder, o *GlBlendFuncSeparateiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstRGB = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcAlpha = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstAlpha = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFuncSeparateiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFuncSeparateiOES) ID() binary.ID      { return binaryIDGlBlendFuncSeparateiOES }
func (*binaryClassGlBlendFuncSeparateiOES) New() binary.Object { return &GlBlendFuncSeparateiOES{} }
func (*binaryClassGlBlendFuncSeparateiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFuncSeparateiOES(e, obj.(*GlBlendFuncSeparateiOES))
}
func (*binaryClassGlBlendFuncSeparateiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFuncSeparateiOES{}
	return obj, doDecodeGlBlendFuncSeparateiOES(d, obj)
}
func (*binaryClassGlBlendFuncSeparateiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFuncSeparateiOES(d, obj.(*GlBlendFuncSeparateiOES))
}
func (*binaryClassGlBlendFuncSeparateiOES) Skip(d binary.Decoder) error {
	return doSkipGlBlendFuncSeparateiOES(d)
}
func (*binaryClassGlBlendFuncSeparateiOES) Schema() *schema.Class {
	return schemaGlBlendFuncSeparateiOES
}

var schemaGlBlendFuncSeparateiOES = &schema.Class{
	TypeID:  binaryIDGlBlendFuncSeparateiOES,
	Package: "gles",
	Name:    "GlBlendFuncSeparateiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstRGB", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstAlpha", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFunciEXT struct{}

func (*GlBlendFunciEXT) Class() binary.Class {
	return (*binaryClassGlBlendFunciEXT)(nil)
}
func doEncodeGlBlendFunciEXT(e binary.Encoder, o *GlBlendFunciEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Src)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Dst)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFunciEXT(d binary.Decoder, o *GlBlendFunciEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Src = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Dst = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFunciEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFunciEXT) ID() binary.ID      { return binaryIDGlBlendFunciEXT }
func (*binaryClassGlBlendFunciEXT) New() binary.Object { return &GlBlendFunciEXT{} }
func (*binaryClassGlBlendFunciEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFunciEXT(e, obj.(*GlBlendFunciEXT))
}
func (*binaryClassGlBlendFunciEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFunciEXT{}
	return obj, doDecodeGlBlendFunciEXT(d, obj)
}
func (*binaryClassGlBlendFunciEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFunciEXT(d, obj.(*GlBlendFunciEXT))
}
func (*binaryClassGlBlendFunciEXT) Skip(d binary.Decoder) error { return doSkipGlBlendFunciEXT(d) }
func (*binaryClassGlBlendFunciEXT) Schema() *schema.Class       { return schemaGlBlendFunciEXT }

var schemaGlBlendFunciEXT = &schema.Class{
	TypeID:  binaryIDGlBlendFunciEXT,
	Package: "gles",
	Name:    "GlBlendFunciEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Src", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Dst", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendFunciOES struct{}

func (*GlBlendFunciOES) Class() binary.Class {
	return (*binaryClassGlBlendFunciOES)(nil)
}
func doEncodeGlBlendFunciOES(e binary.Encoder, o *GlBlendFunciOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buf)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Src)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Dst)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendFunciOES(d binary.Decoder, o *GlBlendFunciOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buf = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Src = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Dst = GLenum(obj)
	}
	return nil
}
func doSkipGlBlendFunciOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendFunciOES) ID() binary.ID      { return binaryIDGlBlendFunciOES }
func (*binaryClassGlBlendFunciOES) New() binary.Object { return &GlBlendFunciOES{} }
func (*binaryClassGlBlendFunciOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendFunciOES(e, obj.(*GlBlendFunciOES))
}
func (*binaryClassGlBlendFunciOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendFunciOES{}
	return obj, doDecodeGlBlendFunciOES(d, obj)
}
func (*binaryClassGlBlendFunciOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendFunciOES(d, obj.(*GlBlendFunciOES))
}
func (*binaryClassGlBlendFunciOES) Skip(d binary.Decoder) error { return doSkipGlBlendFunciOES(d) }
func (*binaryClassGlBlendFunciOES) Schema() *schema.Class       { return schemaGlBlendFunciOES }

var schemaGlBlendFunciOES = &schema.Class{
	TypeID:  binaryIDGlBlendFunciOES,
	Package: "gles",
	Name:    "GlBlendFunciOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buf", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Src", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Dst", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlendParameteriNV struct{}

func (*GlBlendParameteriNV) Class() binary.Class {
	return (*binaryClassGlBlendParameteriNV)(nil)
}
func doEncodeGlBlendParameteriNV(e binary.Encoder, o *GlBlendParameteriNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlendParameteriNV(d binary.Decoder, o *GlBlendParameteriNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlBlendParameteriNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlendParameteriNV) ID() binary.ID      { return binaryIDGlBlendParameteriNV }
func (*binaryClassGlBlendParameteriNV) New() binary.Object { return &GlBlendParameteriNV{} }
func (*binaryClassGlBlendParameteriNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlendParameteriNV(e, obj.(*GlBlendParameteriNV))
}
func (*binaryClassGlBlendParameteriNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlendParameteriNV{}
	return obj, doDecodeGlBlendParameteriNV(d, obj)
}
func (*binaryClassGlBlendParameteriNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlendParameteriNV(d, obj.(*GlBlendParameteriNV))
}
func (*binaryClassGlBlendParameteriNV) Skip(d binary.Decoder) error {
	return doSkipGlBlendParameteriNV(d)
}
func (*binaryClassGlBlendParameteriNV) Schema() *schema.Class { return schemaGlBlendParameteriNV }

var schemaGlBlendParameteriNV = &schema.Class{
	TypeID:  binaryIDGlBlendParameteriNV,
	Package: "gles",
	Name:    "GlBlendParameteriNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlBlitFramebuffer struct{}

func (*GlBlitFramebuffer) Class() binary.Class {
	return (*binaryClassGlBlitFramebuffer)(nil)
}
func doEncodeGlBlitFramebuffer(e binary.Encoder, o *GlBlitFramebuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Filter)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlitFramebuffer(d binary.Decoder, o *GlBlitFramebuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY1 = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Filter = GLenum(obj)
	}
	return nil
}
func doSkipGlBlitFramebuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlitFramebuffer) ID() binary.ID      { return binaryIDGlBlitFramebuffer }
func (*binaryClassGlBlitFramebuffer) New() binary.Object { return &GlBlitFramebuffer{} }
func (*binaryClassGlBlitFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlitFramebuffer(e, obj.(*GlBlitFramebuffer))
}
func (*binaryClassGlBlitFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlitFramebuffer{}
	return obj, doDecodeGlBlitFramebuffer(d, obj)
}
func (*binaryClassGlBlitFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlitFramebuffer(d, obj.(*GlBlitFramebuffer))
}
func (*binaryClassGlBlitFramebuffer) Skip(d binary.Decoder) error { return doSkipGlBlitFramebuffer(d) }
func (*binaryClassGlBlitFramebuffer) Schema() *schema.Class       { return schemaGlBlitFramebuffer }

var schemaGlBlitFramebuffer = &schema.Class{
	TypeID:  binaryIDGlBlitFramebuffer,
	Package: "gles",
	Name:    "GlBlitFramebuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Filter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlitFramebufferANGLE struct{}

func (*GlBlitFramebufferANGLE) Class() binary.Class {
	return (*binaryClassGlBlitFramebufferANGLE)(nil)
}
func doEncodeGlBlitFramebufferANGLE(e binary.Encoder, o *GlBlitFramebufferANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Filter)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlitFramebufferANGLE(d binary.Decoder, o *GlBlitFramebufferANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY1 = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Filter = GLenum(obj)
	}
	return nil
}
func doSkipGlBlitFramebufferANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlitFramebufferANGLE) ID() binary.ID      { return binaryIDGlBlitFramebufferANGLE }
func (*binaryClassGlBlitFramebufferANGLE) New() binary.Object { return &GlBlitFramebufferANGLE{} }
func (*binaryClassGlBlitFramebufferANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlitFramebufferANGLE(e, obj.(*GlBlitFramebufferANGLE))
}
func (*binaryClassGlBlitFramebufferANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlitFramebufferANGLE{}
	return obj, doDecodeGlBlitFramebufferANGLE(d, obj)
}
func (*binaryClassGlBlitFramebufferANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlitFramebufferANGLE(d, obj.(*GlBlitFramebufferANGLE))
}
func (*binaryClassGlBlitFramebufferANGLE) Skip(d binary.Decoder) error {
	return doSkipGlBlitFramebufferANGLE(d)
}
func (*binaryClassGlBlitFramebufferANGLE) Schema() *schema.Class { return schemaGlBlitFramebufferANGLE }

var schemaGlBlitFramebufferANGLE = &schema.Class{
	TypeID:  binaryIDGlBlitFramebufferANGLE,
	Package: "gles",
	Name:    "GlBlitFramebufferANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Filter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBlitFramebufferNV struct{}

func (*GlBlitFramebufferNV) Class() binary.Class {
	return (*binaryClassGlBlitFramebufferNV)(nil)
}
func doEncodeGlBlitFramebufferNV(e binary.Encoder, o *GlBlitFramebufferNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Filter)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBlitFramebufferNV(d binary.Decoder, o *GlBlitFramebufferNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY1 = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Filter = GLenum(obj)
	}
	return nil
}
func doSkipGlBlitFramebufferNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBlitFramebufferNV) ID() binary.ID      { return binaryIDGlBlitFramebufferNV }
func (*binaryClassGlBlitFramebufferNV) New() binary.Object { return &GlBlitFramebufferNV{} }
func (*binaryClassGlBlitFramebufferNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBlitFramebufferNV(e, obj.(*GlBlitFramebufferNV))
}
func (*binaryClassGlBlitFramebufferNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBlitFramebufferNV{}
	return obj, doDecodeGlBlitFramebufferNV(d, obj)
}
func (*binaryClassGlBlitFramebufferNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBlitFramebufferNV(d, obj.(*GlBlitFramebufferNV))
}
func (*binaryClassGlBlitFramebufferNV) Skip(d binary.Decoder) error {
	return doSkipGlBlitFramebufferNV(d)
}
func (*binaryClassGlBlitFramebufferNV) Schema() *schema.Class { return schemaGlBlitFramebufferNV }

var schemaGlBlitFramebufferNV = &schema.Class{
	TypeID:  binaryIDGlBlitFramebufferNV,
	Package: "gles",
	Name:    "GlBlitFramebufferNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Filter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlBufferData struct{}

func (*GlBufferData) Class() binary.Class {
	return (*binaryClassGlBufferData)(nil)
}
func doEncodeGlBufferData(e binary.Encoder, o *GlBufferData) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Usage)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBufferData(d binary.Decoder, o *GlBufferData) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Usage = GLenum(obj)
	}
	return nil
}
func doSkipGlBufferData(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BufferDataPointer)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBufferData) ID() binary.ID      { return binaryIDGlBufferData }
func (*binaryClassGlBufferData) New() binary.Object { return &GlBufferData{} }
func (*binaryClassGlBufferData) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBufferData(e, obj.(*GlBufferData))
}
func (*binaryClassGlBufferData) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBufferData{}
	return obj, doDecodeGlBufferData(d, obj)
}
func (*binaryClassGlBufferData) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBufferData(d, obj.(*GlBufferData))
}
func (*binaryClassGlBufferData) Skip(d binary.Decoder) error { return doSkipGlBufferData(d) }
func (*binaryClassGlBufferData) Schema() *schema.Class       { return schemaGlBufferData }

var schemaGlBufferData = &schema.Class{
	TypeID:  binaryIDGlBufferData,
	Package: "gles",
	Name:    "GlBufferData",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "BufferDataPointer", ID: (*BufferDataPointer)(nil).Class().ID()}},
		{Declared: "Usage", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassVoidᶜᵖ struct{}

func (*Voidᶜᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖ)(nil)
}
func doEncodeVoidᶜᵖ(e binary.Encoder, o *Voidᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᶜᵖ(d binary.Decoder, o *Voidᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᶜᵖ) ID() binary.ID      { return binaryIDVoidᶜᵖ }
func (*binaryClassVoidᶜᵖ) New() binary.Object { return &Voidᶜᵖ{} }
func (*binaryClassVoidᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᶜᵖ(e, obj.(*Voidᶜᵖ))
}
func (*binaryClassVoidᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᶜᵖ{}
	return obj, doDecodeVoidᶜᵖ(d, obj)
}
func (*binaryClassVoidᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᶜᵖ(d, obj.(*Voidᶜᵖ))
}
func (*binaryClassVoidᶜᵖ) Skip(d binary.Decoder) error { return doSkipVoidᶜᵖ(d) }
func (*binaryClassVoidᶜᵖ) Schema() *schema.Class       { return schemaVoidᶜᵖ }

var schemaVoidᶜᵖ = &schema.Class{
	TypeID:  binaryIDVoidᶜᵖ,
	Package: "gles",
	Name:    "Voidᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlBufferStorageEXT struct{}

func (*GlBufferStorageEXT) Class() binary.Class {
	return (*binaryClassGlBufferStorageEXT)(nil)
}
func doEncodeGlBufferStorageEXT(e binary.Encoder, o *GlBufferStorageEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flag)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBufferStorageEXT(d binary.Decoder, o *GlBufferStorageEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flag = GLbitfield(obj)
	}
	return nil
}
func doSkipGlBufferStorageEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBufferStorageEXT) ID() binary.ID      { return binaryIDGlBufferStorageEXT }
func (*binaryClassGlBufferStorageEXT) New() binary.Object { return &GlBufferStorageEXT{} }
func (*binaryClassGlBufferStorageEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBufferStorageEXT(e, obj.(*GlBufferStorageEXT))
}
func (*binaryClassGlBufferStorageEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBufferStorageEXT{}
	return obj, doDecodeGlBufferStorageEXT(d, obj)
}
func (*binaryClassGlBufferStorageEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBufferStorageEXT(d, obj.(*GlBufferStorageEXT))
}
func (*binaryClassGlBufferStorageEXT) Skip(d binary.Decoder) error { return doSkipGlBufferStorageEXT(d) }
func (*binaryClassGlBufferStorageEXT) Schema() *schema.Class       { return schemaGlBufferStorageEXT }

var schemaGlBufferStorageEXT = &schema.Class{
	TypeID:  binaryIDGlBufferStorageEXT,
	Package: "gles",
	Name:    "GlBufferStorageEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Flag", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlBufferSubData struct{}

func (*GlBufferSubData) Class() binary.Class {
	return (*binaryClassGlBufferSubData)(nil)
}
func doEncodeGlBufferSubData(e binary.Encoder, o *GlBufferSubData) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlBufferSubData(d binary.Decoder, o *GlBufferSubData) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlBufferSubData(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BufferDataPointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlBufferSubData) ID() binary.ID      { return binaryIDGlBufferSubData }
func (*binaryClassGlBufferSubData) New() binary.Object { return &GlBufferSubData{} }
func (*binaryClassGlBufferSubData) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlBufferSubData(e, obj.(*GlBufferSubData))
}
func (*binaryClassGlBufferSubData) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlBufferSubData{}
	return obj, doDecodeGlBufferSubData(d, obj)
}
func (*binaryClassGlBufferSubData) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlBufferSubData(d, obj.(*GlBufferSubData))
}
func (*binaryClassGlBufferSubData) Skip(d binary.Decoder) error { return doSkipGlBufferSubData(d) }
func (*binaryClassGlBufferSubData) Schema() *schema.Class       { return schemaGlBufferSubData }

var schemaGlBufferSubData = &schema.Class{
	TypeID:  binaryIDGlBufferSubData,
	Package: "gles",
	Name:    "GlBufferSubData",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "BufferDataPointer", ID: (*BufferDataPointer)(nil).Class().ID()}},
	},
}

type binaryClassGlCheckFramebufferStatus struct{}

func (*GlCheckFramebufferStatus) Class() binary.Class {
	return (*binaryClassGlCheckFramebufferStatus)(nil)
}
func doEncodeGlCheckFramebufferStatus(e binary.Encoder, o *GlCheckFramebufferStatus) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCheckFramebufferStatus(d binary.Decoder, o *GlCheckFramebufferStatus) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlCheckFramebufferStatus(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCheckFramebufferStatus) ID() binary.ID      { return binaryIDGlCheckFramebufferStatus }
func (*binaryClassGlCheckFramebufferStatus) New() binary.Object { return &GlCheckFramebufferStatus{} }
func (*binaryClassGlCheckFramebufferStatus) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCheckFramebufferStatus(e, obj.(*GlCheckFramebufferStatus))
}
func (*binaryClassGlCheckFramebufferStatus) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCheckFramebufferStatus{}
	return obj, doDecodeGlCheckFramebufferStatus(d, obj)
}
func (*binaryClassGlCheckFramebufferStatus) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCheckFramebufferStatus(d, obj.(*GlCheckFramebufferStatus))
}
func (*binaryClassGlCheckFramebufferStatus) Skip(d binary.Decoder) error {
	return doSkipGlCheckFramebufferStatus(d)
}
func (*binaryClassGlCheckFramebufferStatus) Schema() *schema.Class {
	return schemaGlCheckFramebufferStatus
}

var schemaGlCheckFramebufferStatus = &schema.Class{
	TypeID:  binaryIDGlCheckFramebufferStatus,
	Package: "gles",
	Name:    "GlCheckFramebufferStatus",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlClear struct{}

func (*GlClear) Class() binary.Class {
	return (*binaryClassGlClear)(nil)
}
func doEncodeGlClear(e binary.Encoder, o *GlClear) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClear(d binary.Decoder, o *GlClear) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLbitfield(obj)
	}
	return nil
}
func doSkipGlClear(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClear) ID() binary.ID      { return binaryIDGlClear }
func (*binaryClassGlClear) New() binary.Object { return &GlClear{} }
func (*binaryClassGlClear) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClear(e, obj.(*GlClear))
}
func (*binaryClassGlClear) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClear{}
	return obj, doDecodeGlClear(d, obj)
}
func (*binaryClassGlClear) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClear(d, obj.(*GlClear))
}
func (*binaryClassGlClear) Skip(d binary.Decoder) error { return doSkipGlClear(d) }
func (*binaryClassGlClear) Schema() *schema.Class       { return schemaGlClear }

var schemaGlClear = &schema.Class{
	TypeID:  binaryIDGlClear,
	Package: "gles",
	Name:    "GlClear",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlClearBufferfi struct{}

func (*GlClearBufferfi) Class() binary.Class {
	return (*binaryClassGlClearBufferfi)(nil)
}
func doEncodeGlClearBufferfi(e binary.Encoder, o *GlClearBufferfi) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawbuffer)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Depth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stencil)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearBufferfi(d binary.Decoder, o *GlClearBufferfi) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawbuffer = GLint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Depth = GLfloat(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stencil = GLint(obj)
	}
	return nil
}
func doSkipGlClearBufferfi(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearBufferfi) ID() binary.ID      { return binaryIDGlClearBufferfi }
func (*binaryClassGlClearBufferfi) New() binary.Object { return &GlClearBufferfi{} }
func (*binaryClassGlClearBufferfi) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearBufferfi(e, obj.(*GlClearBufferfi))
}
func (*binaryClassGlClearBufferfi) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearBufferfi{}
	return obj, doDecodeGlClearBufferfi(d, obj)
}
func (*binaryClassGlClearBufferfi) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearBufferfi(d, obj.(*GlClearBufferfi))
}
func (*binaryClassGlClearBufferfi) Skip(d binary.Decoder) error { return doSkipGlClearBufferfi(d) }
func (*binaryClassGlClearBufferfi) Schema() *schema.Class       { return schemaGlClearBufferfi }

var schemaGlClearBufferfi = &schema.Class{
	TypeID:  binaryIDGlClearBufferfi,
	Package: "gles",
	Name:    "GlClearBufferfi",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Drawbuffer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Stencil", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlClearBufferfv struct{}

func (*GlClearBufferfv) Class() binary.Class {
	return (*binaryClassGlClearBufferfv)(nil)
}
func doEncodeGlClearBufferfv(e binary.Encoder, o *GlClearBufferfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawbuffer)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearBufferfv(d binary.Decoder, o *GlClearBufferfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawbuffer = GLint(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlClearBufferfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearBufferfv) ID() binary.ID      { return binaryIDGlClearBufferfv }
func (*binaryClassGlClearBufferfv) New() binary.Object { return &GlClearBufferfv{} }
func (*binaryClassGlClearBufferfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearBufferfv(e, obj.(*GlClearBufferfv))
}
func (*binaryClassGlClearBufferfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearBufferfv{}
	return obj, doDecodeGlClearBufferfv(d, obj)
}
func (*binaryClassGlClearBufferfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearBufferfv(d, obj.(*GlClearBufferfv))
}
func (*binaryClassGlClearBufferfv) Skip(d binary.Decoder) error { return doSkipGlClearBufferfv(d) }
func (*binaryClassGlClearBufferfv) Schema() *schema.Class       { return schemaGlClearBufferfv }

var schemaGlClearBufferfv = &schema.Class{
	TypeID:  binaryIDGlClearBufferfv,
	Package: "gles",
	Name:    "GlClearBufferfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Drawbuffer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlClearBufferiv struct{}

func (*GlClearBufferiv) Class() binary.Class {
	return (*binaryClassGlClearBufferiv)(nil)
}
func doEncodeGlClearBufferiv(e binary.Encoder, o *GlClearBufferiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawbuffer)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearBufferiv(d binary.Decoder, o *GlClearBufferiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawbuffer = GLint(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlClearBufferiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearBufferiv) ID() binary.ID      { return binaryIDGlClearBufferiv }
func (*binaryClassGlClearBufferiv) New() binary.Object { return &GlClearBufferiv{} }
func (*binaryClassGlClearBufferiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearBufferiv(e, obj.(*GlClearBufferiv))
}
func (*binaryClassGlClearBufferiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearBufferiv{}
	return obj, doDecodeGlClearBufferiv(d, obj)
}
func (*binaryClassGlClearBufferiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearBufferiv(d, obj.(*GlClearBufferiv))
}
func (*binaryClassGlClearBufferiv) Skip(d binary.Decoder) error { return doSkipGlClearBufferiv(d) }
func (*binaryClassGlClearBufferiv) Schema() *schema.Class       { return schemaGlClearBufferiv }

var schemaGlClearBufferiv = &schema.Class{
	TypeID:  binaryIDGlClearBufferiv,
	Package: "gles",
	Name:    "GlClearBufferiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Drawbuffer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlClearBufferuiv struct{}

func (*GlClearBufferuiv) Class() binary.Class {
	return (*binaryClassGlClearBufferuiv)(nil)
}
func doEncodeGlClearBufferuiv(e binary.Encoder, o *GlClearBufferuiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawbuffer)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearBufferuiv(d binary.Decoder, o *GlClearBufferuiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawbuffer = GLint(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlClearBufferuiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearBufferuiv) ID() binary.ID      { return binaryIDGlClearBufferuiv }
func (*binaryClassGlClearBufferuiv) New() binary.Object { return &GlClearBufferuiv{} }
func (*binaryClassGlClearBufferuiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearBufferuiv(e, obj.(*GlClearBufferuiv))
}
func (*binaryClassGlClearBufferuiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearBufferuiv{}
	return obj, doDecodeGlClearBufferuiv(d, obj)
}
func (*binaryClassGlClearBufferuiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearBufferuiv(d, obj.(*GlClearBufferuiv))
}
func (*binaryClassGlClearBufferuiv) Skip(d binary.Decoder) error { return doSkipGlClearBufferuiv(d) }
func (*binaryClassGlClearBufferuiv) Schema() *schema.Class       { return schemaGlClearBufferuiv }

var schemaGlClearBufferuiv = &schema.Class{
	TypeID:  binaryIDGlClearBufferuiv,
	Package: "gles",
	Name:    "GlClearBufferuiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Drawbuffer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlClearColor struct{}

func (*GlClearColor) Class() binary.Class {
	return (*binaryClassGlClearColor)(nil)
}
func doEncodeGlClearColor(e binary.Encoder, o *GlClearColor) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.R)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.G)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.B)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.A)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearColor(d binary.Decoder, o *GlClearColor) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.R = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.G = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.B = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.A = GLfloat(obj)
	}
	return nil
}
func doSkipGlClearColor(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearColor) ID() binary.ID      { return binaryIDGlClearColor }
func (*binaryClassGlClearColor) New() binary.Object { return &GlClearColor{} }
func (*binaryClassGlClearColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearColor(e, obj.(*GlClearColor))
}
func (*binaryClassGlClearColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearColor{}
	return obj, doDecodeGlClearColor(d, obj)
}
func (*binaryClassGlClearColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearColor(d, obj.(*GlClearColor))
}
func (*binaryClassGlClearColor) Skip(d binary.Decoder) error { return doSkipGlClearColor(d) }
func (*binaryClassGlClearColor) Schema() *schema.Class       { return schemaGlClearColor }

var schemaGlClearColor = &schema.Class{
	TypeID:  binaryIDGlClearColor,
	Package: "gles",
	Name:    "GlClearColor",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "R", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "G", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "B", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "A", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlClearDepthf struct{}

func (*GlClearDepthf) Class() binary.Class {
	return (*binaryClassGlClearDepthf)(nil)
}
func doEncodeGlClearDepthf(e binary.Encoder, o *GlClearDepthf) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Depth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearDepthf(d binary.Decoder, o *GlClearDepthf) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Depth = GLfloat(obj)
	}
	return nil
}
func doSkipGlClearDepthf(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearDepthf) ID() binary.ID      { return binaryIDGlClearDepthf }
func (*binaryClassGlClearDepthf) New() binary.Object { return &GlClearDepthf{} }
func (*binaryClassGlClearDepthf) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearDepthf(e, obj.(*GlClearDepthf))
}
func (*binaryClassGlClearDepthf) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearDepthf{}
	return obj, doDecodeGlClearDepthf(d, obj)
}
func (*binaryClassGlClearDepthf) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearDepthf(d, obj.(*GlClearDepthf))
}
func (*binaryClassGlClearDepthf) Skip(d binary.Decoder) error { return doSkipGlClearDepthf(d) }
func (*binaryClassGlClearDepthf) Schema() *schema.Class       { return schemaGlClearDepthf }

var schemaGlClearDepthf = &schema.Class{
	TypeID:  binaryIDGlClearDepthf,
	Package: "gles",
	Name:    "GlClearDepthf",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlClearStencil struct{}

func (*GlClearStencil) Class() binary.Class {
	return (*binaryClassGlClearStencil)(nil)
}
func doEncodeGlClearStencil(e binary.Encoder, o *GlClearStencil) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stencil)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClearStencil(d binary.Decoder, o *GlClearStencil) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stencil = GLint(obj)
	}
	return nil
}
func doSkipGlClearStencil(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClearStencil) ID() binary.ID      { return binaryIDGlClearStencil }
func (*binaryClassGlClearStencil) New() binary.Object { return &GlClearStencil{} }
func (*binaryClassGlClearStencil) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClearStencil(e, obj.(*GlClearStencil))
}
func (*binaryClassGlClearStencil) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClearStencil{}
	return obj, doDecodeGlClearStencil(d, obj)
}
func (*binaryClassGlClearStencil) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClearStencil(d, obj.(*GlClearStencil))
}
func (*binaryClassGlClearStencil) Skip(d binary.Decoder) error { return doSkipGlClearStencil(d) }
func (*binaryClassGlClearStencil) Schema() *schema.Class       { return schemaGlClearStencil }

var schemaGlClearStencil = &schema.Class{
	TypeID:  binaryIDGlClearStencil,
	Package: "gles",
	Name:    "GlClearStencil",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Stencil", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlClientWaitSync struct{}

func (*GlClientWaitSync) Class() binary.Class {
	return (*binaryClassGlClientWaitSync)(nil)
}
func doEncodeGlClientWaitSync(e binary.Encoder, o *GlClientWaitSync) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SyncFlags)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Timeout)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClientWaitSync(d binary.Decoder, o *GlClientWaitSync) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SyncFlags = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Timeout = GLuint64(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlClientWaitSync(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClientWaitSync) ID() binary.ID      { return binaryIDGlClientWaitSync }
func (*binaryClassGlClientWaitSync) New() binary.Object { return &GlClientWaitSync{} }
func (*binaryClassGlClientWaitSync) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClientWaitSync(e, obj.(*GlClientWaitSync))
}
func (*binaryClassGlClientWaitSync) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClientWaitSync{}
	return obj, doDecodeGlClientWaitSync(d, obj)
}
func (*binaryClassGlClientWaitSync) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClientWaitSync(d, obj.(*GlClientWaitSync))
}
func (*binaryClassGlClientWaitSync) Skip(d binary.Decoder) error { return doSkipGlClientWaitSync(d) }
func (*binaryClassGlClientWaitSync) Schema() *schema.Class       { return schemaGlClientWaitSync }

var schemaGlClientWaitSync = &schema.Class{
	TypeID:  binaryIDGlClientWaitSync,
	Package: "gles",
	Name:    "GlClientWaitSync",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "SyncFlags", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Timeout", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlClientWaitSyncAPPLE struct{}

func (*GlClientWaitSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlClientWaitSyncAPPLE)(nil)
}
func doEncodeGlClientWaitSyncAPPLE(e binary.Encoder, o *GlClientWaitSyncAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flag)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Timeout)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlClientWaitSyncAPPLE(d binary.Decoder, o *GlClientWaitSyncAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flag = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Timeout = GLuint64(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlClientWaitSyncAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlClientWaitSyncAPPLE) ID() binary.ID      { return binaryIDGlClientWaitSyncAPPLE }
func (*binaryClassGlClientWaitSyncAPPLE) New() binary.Object { return &GlClientWaitSyncAPPLE{} }
func (*binaryClassGlClientWaitSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlClientWaitSyncAPPLE(e, obj.(*GlClientWaitSyncAPPLE))
}
func (*binaryClassGlClientWaitSyncAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlClientWaitSyncAPPLE{}
	return obj, doDecodeGlClientWaitSyncAPPLE(d, obj)
}
func (*binaryClassGlClientWaitSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlClientWaitSyncAPPLE(d, obj.(*GlClientWaitSyncAPPLE))
}
func (*binaryClassGlClientWaitSyncAPPLE) Skip(d binary.Decoder) error {
	return doSkipGlClientWaitSyncAPPLE(d)
}
func (*binaryClassGlClientWaitSyncAPPLE) Schema() *schema.Class { return schemaGlClientWaitSyncAPPLE }

var schemaGlClientWaitSyncAPPLE = &schema.Class{
	TypeID:  binaryIDGlClientWaitSyncAPPLE,
	Package: "gles",
	Name:    "GlClientWaitSyncAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Flag", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Timeout", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlColorMask struct{}

func (*GlColorMask) Class() binary.Class {
	return (*binaryClassGlColorMask)(nil)
}
func doEncodeGlColorMask(e binary.Encoder, o *GlColorMask) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Red)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Green)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Blue)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Alpha)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlColorMask(d binary.Decoder, o *GlColorMask) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Red = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Green = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Blue = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Alpha = GLboolean(obj)
	}
	return nil
}
func doSkipGlColorMask(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlColorMask) ID() binary.ID      { return binaryIDGlColorMask }
func (*binaryClassGlColorMask) New() binary.Object { return &GlColorMask{} }
func (*binaryClassGlColorMask) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlColorMask(e, obj.(*GlColorMask))
}
func (*binaryClassGlColorMask) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlColorMask{}
	return obj, doDecodeGlColorMask(d, obj)
}
func (*binaryClassGlColorMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlColorMask(d, obj.(*GlColorMask))
}
func (*binaryClassGlColorMask) Skip(d binary.Decoder) error { return doSkipGlColorMask(d) }
func (*binaryClassGlColorMask) Schema() *schema.Class       { return schemaGlColorMask }

var schemaGlColorMask = &schema.Class{
	TypeID:  binaryIDGlColorMask,
	Package: "gles",
	Name:    "GlColorMask",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Red", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Green", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Blue", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Alpha", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlColorMaskiEXT struct{}

func (*GlColorMaskiEXT) Class() binary.Class {
	return (*binaryClassGlColorMaskiEXT)(nil)
}
func doEncodeGlColorMaskiEXT(e binary.Encoder, o *GlColorMaskiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.R)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.G)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.B)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.A)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlColorMaskiEXT(d binary.Decoder, o *GlColorMaskiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.R = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.G = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.B = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.A = GLboolean(obj)
	}
	return nil
}
func doSkipGlColorMaskiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlColorMaskiEXT) ID() binary.ID      { return binaryIDGlColorMaskiEXT }
func (*binaryClassGlColorMaskiEXT) New() binary.Object { return &GlColorMaskiEXT{} }
func (*binaryClassGlColorMaskiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlColorMaskiEXT(e, obj.(*GlColorMaskiEXT))
}
func (*binaryClassGlColorMaskiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlColorMaskiEXT{}
	return obj, doDecodeGlColorMaskiEXT(d, obj)
}
func (*binaryClassGlColorMaskiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlColorMaskiEXT(d, obj.(*GlColorMaskiEXT))
}
func (*binaryClassGlColorMaskiEXT) Skip(d binary.Decoder) error { return doSkipGlColorMaskiEXT(d) }
func (*binaryClassGlColorMaskiEXT) Schema() *schema.Class       { return schemaGlColorMaskiEXT }

var schemaGlColorMaskiEXT = &schema.Class{
	TypeID:  binaryIDGlColorMaskiEXT,
	Package: "gles",
	Name:    "GlColorMaskiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "R", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "G", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "B", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "A", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlColorMaskiOES struct{}

func (*GlColorMaskiOES) Class() binary.Class {
	return (*binaryClassGlColorMaskiOES)(nil)
}
func doEncodeGlColorMaskiOES(e binary.Encoder, o *GlColorMaskiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.R)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.G)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.B)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.A)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlColorMaskiOES(d binary.Decoder, o *GlColorMaskiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.R = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.G = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.B = GLboolean(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.A = GLboolean(obj)
	}
	return nil
}
func doSkipGlColorMaskiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlColorMaskiOES) ID() binary.ID      { return binaryIDGlColorMaskiOES }
func (*binaryClassGlColorMaskiOES) New() binary.Object { return &GlColorMaskiOES{} }
func (*binaryClassGlColorMaskiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlColorMaskiOES(e, obj.(*GlColorMaskiOES))
}
func (*binaryClassGlColorMaskiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlColorMaskiOES{}
	return obj, doDecodeGlColorMaskiOES(d, obj)
}
func (*binaryClassGlColorMaskiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlColorMaskiOES(d, obj.(*GlColorMaskiOES))
}
func (*binaryClassGlColorMaskiOES) Skip(d binary.Decoder) error { return doSkipGlColorMaskiOES(d) }
func (*binaryClassGlColorMaskiOES) Schema() *schema.Class       { return schemaGlColorMaskiOES }

var schemaGlColorMaskiOES = &schema.Class{
	TypeID:  binaryIDGlColorMaskiOES,
	Package: "gles",
	Name:    "GlColorMaskiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "R", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "G", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "B", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "A", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlCompileShader struct{}

func (*GlCompileShader) Class() binary.Class {
	return (*binaryClassGlCompileShader)(nil)
}
func doEncodeGlCompileShader(e binary.Encoder, o *GlCompileShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompileShader(d binary.Decoder, o *GlCompileShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	return nil
}
func doSkipGlCompileShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompileShader) ID() binary.ID      { return binaryIDGlCompileShader }
func (*binaryClassGlCompileShader) New() binary.Object { return &GlCompileShader{} }
func (*binaryClassGlCompileShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompileShader(e, obj.(*GlCompileShader))
}
func (*binaryClassGlCompileShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompileShader{}
	return obj, doDecodeGlCompileShader(d, obj)
}
func (*binaryClassGlCompileShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompileShader(d, obj.(*GlCompileShader))
}
func (*binaryClassGlCompileShader) Skip(d binary.Decoder) error { return doSkipGlCompileShader(d) }
func (*binaryClassGlCompileShader) Schema() *schema.Class       { return schemaGlCompileShader }

var schemaGlCompileShader = &schema.Class{
	TypeID:  binaryIDGlCompileShader,
	Package: "gles",
	Name:    "GlCompileShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
	},
}

type binaryClassTexturePointer struct{}

func (*TexturePointer) Class() binary.Class {
	return (*binaryClassTexturePointer)(nil)
}
func doEncodeTexturePointer(e binary.Encoder, o *TexturePointer) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeTexturePointer(d binary.Decoder, o *TexturePointer) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipTexturePointer(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTexturePointer) ID() binary.ID      { return binaryIDTexturePointer }
func (*binaryClassTexturePointer) New() binary.Object { return &TexturePointer{} }
func (*binaryClassTexturePointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTexturePointer(e, obj.(*TexturePointer))
}
func (*binaryClassTexturePointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TexturePointer{}
	return obj, doDecodeTexturePointer(d, obj)
}
func (*binaryClassTexturePointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTexturePointer(d, obj.(*TexturePointer))
}
func (*binaryClassTexturePointer) Skip(d binary.Decoder) error { return doSkipTexturePointer(d) }
func (*binaryClassTexturePointer) Schema() *schema.Class       { return schemaTexturePointer }

var schemaTexturePointer = &schema.Class{
	TypeID:  binaryIDTexturePointer,
	Package: "gles",
	Name:    "TexturePointer",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexImage2D struct{}

func (*GlCompressedTexImage2D) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage2D)(nil)
}
func doEncodeGlCompressedTexImage2D(e binary.Encoder, o *GlCompressedTexImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexImage2D(d binary.Decoder, o *GlCompressedTexImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexImage2D) ID() binary.ID      { return binaryIDGlCompressedTexImage2D }
func (*binaryClassGlCompressedTexImage2D) New() binary.Object { return &GlCompressedTexImage2D{} }
func (*binaryClassGlCompressedTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexImage2D(e, obj.(*GlCompressedTexImage2D))
}
func (*binaryClassGlCompressedTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexImage2D{}
	return obj, doDecodeGlCompressedTexImage2D(d, obj)
}
func (*binaryClassGlCompressedTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexImage2D(d, obj.(*GlCompressedTexImage2D))
}
func (*binaryClassGlCompressedTexImage2D) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexImage2D(d)
}
func (*binaryClassGlCompressedTexImage2D) Schema() *schema.Class { return schemaGlCompressedTexImage2D }

var schemaGlCompressedTexImage2D = &schema.Class{
	TypeID:  binaryIDGlCompressedTexImage2D,
	Package: "gles",
	Name:    "GlCompressedTexImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer", ID: (*TexturePointer)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexImage3D struct{}

func (*GlCompressedTexImage3D) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage3D)(nil)
}
func doEncodeGlCompressedTexImage3D(e binary.Encoder, o *GlCompressedTexImage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexImage3D(d binary.Decoder, o *GlCompressedTexImage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexImage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexImage3D) ID() binary.ID      { return binaryIDGlCompressedTexImage3D }
func (*binaryClassGlCompressedTexImage3D) New() binary.Object { return &GlCompressedTexImage3D{} }
func (*binaryClassGlCompressedTexImage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexImage3D(e, obj.(*GlCompressedTexImage3D))
}
func (*binaryClassGlCompressedTexImage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexImage3D{}
	return obj, doDecodeGlCompressedTexImage3D(d, obj)
}
func (*binaryClassGlCompressedTexImage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexImage3D(d, obj.(*GlCompressedTexImage3D))
}
func (*binaryClassGlCompressedTexImage3D) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexImage3D(d)
}
func (*binaryClassGlCompressedTexImage3D) Schema() *schema.Class { return schemaGlCompressedTexImage3D }

var schemaGlCompressedTexImage3D = &schema.Class{
	TypeID:  binaryIDGlCompressedTexImage3D,
	Package: "gles",
	Name:    "GlCompressedTexImage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexImage3DOES struct{}

func (*GlCompressedTexImage3DOES) Class() binary.Class {
	return (*binaryClassGlCompressedTexImage3DOES)(nil)
}
func doEncodeGlCompressedTexImage3DOES(e binary.Encoder, o *GlCompressedTexImage3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexImage3DOES(d binary.Decoder, o *GlCompressedTexImage3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexImage3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexImage3DOES) ID() binary.ID      { return binaryIDGlCompressedTexImage3DOES }
func (*binaryClassGlCompressedTexImage3DOES) New() binary.Object { return &GlCompressedTexImage3DOES{} }
func (*binaryClassGlCompressedTexImage3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexImage3DOES(e, obj.(*GlCompressedTexImage3DOES))
}
func (*binaryClassGlCompressedTexImage3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexImage3DOES{}
	return obj, doDecodeGlCompressedTexImage3DOES(d, obj)
}
func (*binaryClassGlCompressedTexImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexImage3DOES(d, obj.(*GlCompressedTexImage3DOES))
}
func (*binaryClassGlCompressedTexImage3DOES) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexImage3DOES(d)
}
func (*binaryClassGlCompressedTexImage3DOES) Schema() *schema.Class {
	return schemaGlCompressedTexImage3DOES
}

var schemaGlCompressedTexImage3DOES = &schema.Class{
	TypeID:  binaryIDGlCompressedTexImage3DOES,
	Package: "gles",
	Name:    "GlCompressedTexImage3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexSubImage2D struct{}

func (*GlCompressedTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage2D)(nil)
}
func doEncodeGlCompressedTexSubImage2D(e binary.Encoder, o *GlCompressedTexSubImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexSubImage2D(d binary.Decoder, o *GlCompressedTexSubImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexSubImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexSubImage2D) ID() binary.ID      { return binaryIDGlCompressedTexSubImage2D }
func (*binaryClassGlCompressedTexSubImage2D) New() binary.Object { return &GlCompressedTexSubImage2D{} }
func (*binaryClassGlCompressedTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexSubImage2D(e, obj.(*GlCompressedTexSubImage2D))
}
func (*binaryClassGlCompressedTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexSubImage2D{}
	return obj, doDecodeGlCompressedTexSubImage2D(d, obj)
}
func (*binaryClassGlCompressedTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexSubImage2D(d, obj.(*GlCompressedTexSubImage2D))
}
func (*binaryClassGlCompressedTexSubImage2D) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexSubImage2D(d)
}
func (*binaryClassGlCompressedTexSubImage2D) Schema() *schema.Class {
	return schemaGlCompressedTexSubImage2D
}

var schemaGlCompressedTexSubImage2D = &schema.Class{
	TypeID:  binaryIDGlCompressedTexSubImage2D,
	Package: "gles",
	Name:    "GlCompressedTexSubImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer", ID: (*TexturePointer)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexSubImage3D struct{}

func (*GlCompressedTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage3D)(nil)
}
func doEncodeGlCompressedTexSubImage3D(e binary.Encoder, o *GlCompressedTexSubImage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexSubImage3D(d binary.Decoder, o *GlCompressedTexSubImage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexSubImage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexSubImage3D) ID() binary.ID      { return binaryIDGlCompressedTexSubImage3D }
func (*binaryClassGlCompressedTexSubImage3D) New() binary.Object { return &GlCompressedTexSubImage3D{} }
func (*binaryClassGlCompressedTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexSubImage3D(e, obj.(*GlCompressedTexSubImage3D))
}
func (*binaryClassGlCompressedTexSubImage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexSubImage3D{}
	return obj, doDecodeGlCompressedTexSubImage3D(d, obj)
}
func (*binaryClassGlCompressedTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexSubImage3D(d, obj.(*GlCompressedTexSubImage3D))
}
func (*binaryClassGlCompressedTexSubImage3D) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexSubImage3D(d)
}
func (*binaryClassGlCompressedTexSubImage3D) Schema() *schema.Class {
	return schemaGlCompressedTexSubImage3D
}

var schemaGlCompressedTexSubImage3D = &schema.Class{
	TypeID:  binaryIDGlCompressedTexSubImage3D,
	Package: "gles",
	Name:    "GlCompressedTexSubImage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCompressedTexSubImage3DOES struct{}

func (*GlCompressedTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlCompressedTexSubImage3DOES)(nil)
}
func doEncodeGlCompressedTexSubImage3DOES(e binary.Encoder, o *GlCompressedTexSubImage3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ImageSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCompressedTexSubImage3DOES(d binary.Decoder, o *GlCompressedTexSubImage3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ImageSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlCompressedTexSubImage3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCompressedTexSubImage3DOES) ID() binary.ID {
	return binaryIDGlCompressedTexSubImage3DOES
}
func (*binaryClassGlCompressedTexSubImage3DOES) New() binary.Object {
	return &GlCompressedTexSubImage3DOES{}
}
func (*binaryClassGlCompressedTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCompressedTexSubImage3DOES(e, obj.(*GlCompressedTexSubImage3DOES))
}
func (*binaryClassGlCompressedTexSubImage3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCompressedTexSubImage3DOES{}
	return obj, doDecodeGlCompressedTexSubImage3DOES(d, obj)
}
func (*binaryClassGlCompressedTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCompressedTexSubImage3DOES(d, obj.(*GlCompressedTexSubImage3DOES))
}
func (*binaryClassGlCompressedTexSubImage3DOES) Skip(d binary.Decoder) error {
	return doSkipGlCompressedTexSubImage3DOES(d)
}
func (*binaryClassGlCompressedTexSubImage3DOES) Schema() *schema.Class {
	return schemaGlCompressedTexSubImage3DOES
}

var schemaGlCompressedTexSubImage3DOES = &schema.Class{
	TypeID:  binaryIDGlCompressedTexSubImage3DOES,
	Package: "gles",
	Name:    "GlCompressedTexSubImage3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ImageSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCopyBufferSubData struct{}

func (*GlCopyBufferSubData) Class() binary.Class {
	return (*binaryClassGlCopyBufferSubData)(nil)
}
func doEncodeGlCopyBufferSubData(e binary.Encoder, o *GlCopyBufferSubData) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ReadTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.WriteTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ReadOffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.WriteOffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyBufferSubData(d binary.Decoder, o *GlCopyBufferSubData) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ReadTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.WriteTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ReadOffset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.WriteOffset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlCopyBufferSubData(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyBufferSubData) ID() binary.ID      { return binaryIDGlCopyBufferSubData }
func (*binaryClassGlCopyBufferSubData) New() binary.Object { return &GlCopyBufferSubData{} }
func (*binaryClassGlCopyBufferSubData) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyBufferSubData(e, obj.(*GlCopyBufferSubData))
}
func (*binaryClassGlCopyBufferSubData) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyBufferSubData{}
	return obj, doDecodeGlCopyBufferSubData(d, obj)
}
func (*binaryClassGlCopyBufferSubData) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyBufferSubData(d, obj.(*GlCopyBufferSubData))
}
func (*binaryClassGlCopyBufferSubData) Skip(d binary.Decoder) error {
	return doSkipGlCopyBufferSubData(d)
}
func (*binaryClassGlCopyBufferSubData) Schema() *schema.Class { return schemaGlCopyBufferSubData }

var schemaGlCopyBufferSubData = &schema.Class{
	TypeID:  binaryIDGlCopyBufferSubData,
	Package: "gles",
	Name:    "GlCopyBufferSubData",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ReadTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "WriteTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ReadOffset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "WriteOffset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlCopyBufferSubDataNV struct{}

func (*GlCopyBufferSubDataNV) Class() binary.Class {
	return (*binaryClassGlCopyBufferSubDataNV)(nil)
}
func doEncodeGlCopyBufferSubDataNV(e binary.Encoder, o *GlCopyBufferSubDataNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ReadTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.WriteTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ReadOffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.WriteOffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyBufferSubDataNV(d binary.Decoder, o *GlCopyBufferSubDataNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ReadTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.WriteTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ReadOffset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.WriteOffset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlCopyBufferSubDataNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyBufferSubDataNV) ID() binary.ID      { return binaryIDGlCopyBufferSubDataNV }
func (*binaryClassGlCopyBufferSubDataNV) New() binary.Object { return &GlCopyBufferSubDataNV{} }
func (*binaryClassGlCopyBufferSubDataNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyBufferSubDataNV(e, obj.(*GlCopyBufferSubDataNV))
}
func (*binaryClassGlCopyBufferSubDataNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyBufferSubDataNV{}
	return obj, doDecodeGlCopyBufferSubDataNV(d, obj)
}
func (*binaryClassGlCopyBufferSubDataNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyBufferSubDataNV(d, obj.(*GlCopyBufferSubDataNV))
}
func (*binaryClassGlCopyBufferSubDataNV) Skip(d binary.Decoder) error {
	return doSkipGlCopyBufferSubDataNV(d)
}
func (*binaryClassGlCopyBufferSubDataNV) Schema() *schema.Class { return schemaGlCopyBufferSubDataNV }

var schemaGlCopyBufferSubDataNV = &schema.Class{
	TypeID:  binaryIDGlCopyBufferSubDataNV,
	Package: "gles",
	Name:    "GlCopyBufferSubDataNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ReadTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "WriteTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ReadOffset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "WriteOffset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlCopyImageSubDataEXT struct{}

func (*GlCopyImageSubDataEXT) Class() binary.Class {
	return (*binaryClassGlCopyImageSubDataEXT)(nil)
}
func doEncodeGlCopyImageSubDataEXT(e binary.Encoder, o *GlCopyImageSubDataEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcLevel)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcZ)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstLevel)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstZ)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcWidth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcHeight)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcDepth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyImageSubDataEXT(d binary.Decoder, o *GlCopyImageSubDataEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcLevel = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcZ = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstLevel = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstZ = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcWidth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcHeight = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcDepth = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyImageSubDataEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyImageSubDataEXT) ID() binary.ID      { return binaryIDGlCopyImageSubDataEXT }
func (*binaryClassGlCopyImageSubDataEXT) New() binary.Object { return &GlCopyImageSubDataEXT{} }
func (*binaryClassGlCopyImageSubDataEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyImageSubDataEXT(e, obj.(*GlCopyImageSubDataEXT))
}
func (*binaryClassGlCopyImageSubDataEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyImageSubDataEXT{}
	return obj, doDecodeGlCopyImageSubDataEXT(d, obj)
}
func (*binaryClassGlCopyImageSubDataEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyImageSubDataEXT(d, obj.(*GlCopyImageSubDataEXT))
}
func (*binaryClassGlCopyImageSubDataEXT) Skip(d binary.Decoder) error {
	return doSkipGlCopyImageSubDataEXT(d)
}
func (*binaryClassGlCopyImageSubDataEXT) Schema() *schema.Class { return schemaGlCopyImageSubDataEXT }

var schemaGlCopyImageSubDataEXT = &schema.Class{
	TypeID:  binaryIDGlCopyImageSubDataEXT,
	Package: "gles",
	Name:    "GlCopyImageSubDataEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcX", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcZ", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "DstTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstZ", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcWidth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "SrcHeight", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "SrcDepth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCopyImageSubDataOES struct{}

func (*GlCopyImageSubDataOES) Class() binary.Class {
	return (*binaryClassGlCopyImageSubDataOES)(nil)
}
func doEncodeGlCopyImageSubDataOES(e binary.Encoder, o *GlCopyImageSubDataOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcLevel)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcX)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcY)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcZ)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DstTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstLevel)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstX)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstY)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DstZ)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcWidth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcHeight)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SrcDepth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyImageSubDataOES(d binary.Decoder, o *GlCopyImageSubDataOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcLevel = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcX = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcY = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcZ = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DstTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstLevel = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstX = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstY = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DstZ = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcWidth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcHeight = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SrcDepth = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyImageSubDataOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyImageSubDataOES) ID() binary.ID      { return binaryIDGlCopyImageSubDataOES }
func (*binaryClassGlCopyImageSubDataOES) New() binary.Object { return &GlCopyImageSubDataOES{} }
func (*binaryClassGlCopyImageSubDataOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyImageSubDataOES(e, obj.(*GlCopyImageSubDataOES))
}
func (*binaryClassGlCopyImageSubDataOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyImageSubDataOES{}
	return obj, doDecodeGlCopyImageSubDataOES(d, obj)
}
func (*binaryClassGlCopyImageSubDataOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyImageSubDataOES(d, obj.(*GlCopyImageSubDataOES))
}
func (*binaryClassGlCopyImageSubDataOES) Skip(d binary.Decoder) error {
	return doSkipGlCopyImageSubDataOES(d)
}
func (*binaryClassGlCopyImageSubDataOES) Schema() *schema.Class { return schemaGlCopyImageSubDataOES }

var schemaGlCopyImageSubDataOES = &schema.Class{
	TypeID:  binaryIDGlCopyImageSubDataOES,
	Package: "gles",
	Name:    "GlCopyImageSubDataOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "SrcName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SrcLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcX", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcY", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcZ", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "DstTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DstLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstX", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstY", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "DstZ", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SrcWidth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "SrcHeight", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "SrcDepth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCopyPathNV struct{}

func (*GlCopyPathNV) Class() binary.Class {
	return (*binaryClassGlCopyPathNV)(nil)
}
func doEncodeGlCopyPathNV(e binary.Encoder, o *GlCopyPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ResultPath)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcPath)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyPathNV(d binary.Decoder, o *GlCopyPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ResultPath = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcPath = GLuint(obj)
	}
	return nil
}
func doSkipGlCopyPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyPathNV) ID() binary.ID      { return binaryIDGlCopyPathNV }
func (*binaryClassGlCopyPathNV) New() binary.Object { return &GlCopyPathNV{} }
func (*binaryClassGlCopyPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyPathNV(e, obj.(*GlCopyPathNV))
}
func (*binaryClassGlCopyPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyPathNV{}
	return obj, doDecodeGlCopyPathNV(d, obj)
}
func (*binaryClassGlCopyPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyPathNV(d, obj.(*GlCopyPathNV))
}
func (*binaryClassGlCopyPathNV) Skip(d binary.Decoder) error { return doSkipGlCopyPathNV(d) }
func (*binaryClassGlCopyPathNV) Schema() *schema.Class       { return schemaGlCopyPathNV }

var schemaGlCopyPathNV = &schema.Class{
	TypeID:  binaryIDGlCopyPathNV,
	Package: "gles",
	Name:    "GlCopyPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ResultPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlCopyTexImage2D struct{}

func (*GlCopyTexImage2D) Class() binary.Class {
	return (*binaryClassGlCopyTexImage2D)(nil)
}
func doEncodeGlCopyTexImage2D(e binary.Encoder, o *GlCopyTexImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyTexImage2D(d binary.Decoder, o *GlCopyTexImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	return nil
}
func doSkipGlCopyTexImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyTexImage2D) ID() binary.ID      { return binaryIDGlCopyTexImage2D }
func (*binaryClassGlCopyTexImage2D) New() binary.Object { return &GlCopyTexImage2D{} }
func (*binaryClassGlCopyTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyTexImage2D(e, obj.(*GlCopyTexImage2D))
}
func (*binaryClassGlCopyTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyTexImage2D{}
	return obj, doDecodeGlCopyTexImage2D(d, obj)
}
func (*binaryClassGlCopyTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyTexImage2D(d, obj.(*GlCopyTexImage2D))
}
func (*binaryClassGlCopyTexImage2D) Skip(d binary.Decoder) error { return doSkipGlCopyTexImage2D(d) }
func (*binaryClassGlCopyTexImage2D) Schema() *schema.Class       { return schemaGlCopyTexImage2D }

var schemaGlCopyTexImage2D = &schema.Class{
	TypeID:  binaryIDGlCopyTexImage2D,
	Package: "gles",
	Name:    "GlCopyTexImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlCopyTexSubImage2D struct{}

func (*GlCopyTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage2D)(nil)
}
func doEncodeGlCopyTexSubImage2D(e binary.Encoder, o *GlCopyTexSubImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyTexSubImage2D(d binary.Decoder, o *GlCopyTexSubImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyTexSubImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyTexSubImage2D) ID() binary.ID      { return binaryIDGlCopyTexSubImage2D }
func (*binaryClassGlCopyTexSubImage2D) New() binary.Object { return &GlCopyTexSubImage2D{} }
func (*binaryClassGlCopyTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyTexSubImage2D(e, obj.(*GlCopyTexSubImage2D))
}
func (*binaryClassGlCopyTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyTexSubImage2D{}
	return obj, doDecodeGlCopyTexSubImage2D(d, obj)
}
func (*binaryClassGlCopyTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyTexSubImage2D(d, obj.(*GlCopyTexSubImage2D))
}
func (*binaryClassGlCopyTexSubImage2D) Skip(d binary.Decoder) error {
	return doSkipGlCopyTexSubImage2D(d)
}
func (*binaryClassGlCopyTexSubImage2D) Schema() *schema.Class { return schemaGlCopyTexSubImage2D }

var schemaGlCopyTexSubImage2D = &schema.Class{
	TypeID:  binaryIDGlCopyTexSubImage2D,
	Package: "gles",
	Name:    "GlCopyTexSubImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCopyTexSubImage3D struct{}

func (*GlCopyTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage3D)(nil)
}
func doEncodeGlCopyTexSubImage3D(e binary.Encoder, o *GlCopyTexSubImage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyTexSubImage3D(d binary.Decoder, o *GlCopyTexSubImage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyTexSubImage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyTexSubImage3D) ID() binary.ID      { return binaryIDGlCopyTexSubImage3D }
func (*binaryClassGlCopyTexSubImage3D) New() binary.Object { return &GlCopyTexSubImage3D{} }
func (*binaryClassGlCopyTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyTexSubImage3D(e, obj.(*GlCopyTexSubImage3D))
}
func (*binaryClassGlCopyTexSubImage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyTexSubImage3D{}
	return obj, doDecodeGlCopyTexSubImage3D(d, obj)
}
func (*binaryClassGlCopyTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyTexSubImage3D(d, obj.(*GlCopyTexSubImage3D))
}
func (*binaryClassGlCopyTexSubImage3D) Skip(d binary.Decoder) error {
	return doSkipGlCopyTexSubImage3D(d)
}
func (*binaryClassGlCopyTexSubImage3D) Schema() *schema.Class { return schemaGlCopyTexSubImage3D }

var schemaGlCopyTexSubImage3D = &schema.Class{
	TypeID:  binaryIDGlCopyTexSubImage3D,
	Package: "gles",
	Name:    "GlCopyTexSubImage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCopyTexSubImage3DOES struct{}

func (*GlCopyTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlCopyTexSubImage3DOES)(nil)
}
func doEncodeGlCopyTexSubImage3DOES(e binary.Encoder, o *GlCopyTexSubImage3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyTexSubImage3DOES(d binary.Decoder, o *GlCopyTexSubImage3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyTexSubImage3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyTexSubImage3DOES) ID() binary.ID      { return binaryIDGlCopyTexSubImage3DOES }
func (*binaryClassGlCopyTexSubImage3DOES) New() binary.Object { return &GlCopyTexSubImage3DOES{} }
func (*binaryClassGlCopyTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyTexSubImage3DOES(e, obj.(*GlCopyTexSubImage3DOES))
}
func (*binaryClassGlCopyTexSubImage3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyTexSubImage3DOES{}
	return obj, doDecodeGlCopyTexSubImage3DOES(d, obj)
}
func (*binaryClassGlCopyTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyTexSubImage3DOES(d, obj.(*GlCopyTexSubImage3DOES))
}
func (*binaryClassGlCopyTexSubImage3DOES) Skip(d binary.Decoder) error {
	return doSkipGlCopyTexSubImage3DOES(d)
}
func (*binaryClassGlCopyTexSubImage3DOES) Schema() *schema.Class { return schemaGlCopyTexSubImage3DOES }

var schemaGlCopyTexSubImage3DOES = &schema.Class{
	TypeID:  binaryIDGlCopyTexSubImage3DOES,
	Package: "gles",
	Name:    "GlCopyTexSubImage3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCopyTextureLevelsAPPLE struct{}

func (*GlCopyTextureLevelsAPPLE) Class() binary.Class {
	return (*binaryClassGlCopyTextureLevelsAPPLE)(nil)
}
func doEncodeGlCopyTextureLevelsAPPLE(e binary.Encoder, o *GlCopyTextureLevelsAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DestinationTexture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SourceTexture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SourceBaseLevel)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.SourceLevelCount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCopyTextureLevelsAPPLE(d binary.Decoder, o *GlCopyTextureLevelsAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DestinationTexture = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SourceTexture = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SourceBaseLevel = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.SourceLevelCount = GLsizei(obj)
	}
	return nil
}
func doSkipGlCopyTextureLevelsAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCopyTextureLevelsAPPLE) ID() binary.ID      { return binaryIDGlCopyTextureLevelsAPPLE }
func (*binaryClassGlCopyTextureLevelsAPPLE) New() binary.Object { return &GlCopyTextureLevelsAPPLE{} }
func (*binaryClassGlCopyTextureLevelsAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCopyTextureLevelsAPPLE(e, obj.(*GlCopyTextureLevelsAPPLE))
}
func (*binaryClassGlCopyTextureLevelsAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCopyTextureLevelsAPPLE{}
	return obj, doDecodeGlCopyTextureLevelsAPPLE(d, obj)
}
func (*binaryClassGlCopyTextureLevelsAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCopyTextureLevelsAPPLE(d, obj.(*GlCopyTextureLevelsAPPLE))
}
func (*binaryClassGlCopyTextureLevelsAPPLE) Skip(d binary.Decoder) error {
	return doSkipGlCopyTextureLevelsAPPLE(d)
}
func (*binaryClassGlCopyTextureLevelsAPPLE) Schema() *schema.Class {
	return schemaGlCopyTextureLevelsAPPLE
}

var schemaGlCopyTextureLevelsAPPLE = &schema.Class{
	TypeID:  binaryIDGlCopyTextureLevelsAPPLE,
	Package: "gles",
	Name:    "GlCopyTextureLevelsAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DestinationTexture", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SourceTexture", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SourceBaseLevel", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "SourceLevelCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlCoverFillPathInstancedNV struct{}

func (*GlCoverFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlCoverFillPathInstancedNV)(nil)
}
func doEncodeGlCoverFillPathInstancedNV(e binary.Encoder, o *GlCoverFillPathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverFillPathInstancedNV(d binary.Decoder, o *GlCoverFillPathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlCoverFillPathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverFillPathInstancedNV) ID() binary.ID {
	return binaryIDGlCoverFillPathInstancedNV
}
func (*binaryClassGlCoverFillPathInstancedNV) New() binary.Object {
	return &GlCoverFillPathInstancedNV{}
}
func (*binaryClassGlCoverFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverFillPathInstancedNV(e, obj.(*GlCoverFillPathInstancedNV))
}
func (*binaryClassGlCoverFillPathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverFillPathInstancedNV{}
	return obj, doDecodeGlCoverFillPathInstancedNV(d, obj)
}
func (*binaryClassGlCoverFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverFillPathInstancedNV(d, obj.(*GlCoverFillPathInstancedNV))
}
func (*binaryClassGlCoverFillPathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverFillPathInstancedNV(d)
}
func (*binaryClassGlCoverFillPathInstancedNV) Schema() *schema.Class {
	return schemaGlCoverFillPathInstancedNV
}

var schemaGlCoverFillPathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlCoverFillPathInstancedNV,
	Package: "gles",
	Name:    "GlCoverFillPathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCoverFillPathNV struct{}

func (*GlCoverFillPathNV) Class() binary.Class {
	return (*binaryClassGlCoverFillPathNV)(nil)
}
func doEncodeGlCoverFillPathNV(e binary.Encoder, o *GlCoverFillPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverFillPathNV(d binary.Decoder, o *GlCoverFillPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	return nil
}
func doSkipGlCoverFillPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverFillPathNV) ID() binary.ID      { return binaryIDGlCoverFillPathNV }
func (*binaryClassGlCoverFillPathNV) New() binary.Object { return &GlCoverFillPathNV{} }
func (*binaryClassGlCoverFillPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverFillPathNV(e, obj.(*GlCoverFillPathNV))
}
func (*binaryClassGlCoverFillPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverFillPathNV{}
	return obj, doDecodeGlCoverFillPathNV(d, obj)
}
func (*binaryClassGlCoverFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverFillPathNV(d, obj.(*GlCoverFillPathNV))
}
func (*binaryClassGlCoverFillPathNV) Skip(d binary.Decoder) error { return doSkipGlCoverFillPathNV(d) }
func (*binaryClassGlCoverFillPathNV) Schema() *schema.Class       { return schemaGlCoverFillPathNV }

var schemaGlCoverFillPathNV = &schema.Class{
	TypeID:  binaryIDGlCoverFillPathNV,
	Package: "gles",
	Name:    "GlCoverFillPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlCoverStrokePathInstancedNV struct{}

func (*GlCoverStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlCoverStrokePathInstancedNV)(nil)
}
func doEncodeGlCoverStrokePathInstancedNV(e binary.Encoder, o *GlCoverStrokePathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverStrokePathInstancedNV(d binary.Decoder, o *GlCoverStrokePathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlCoverStrokePathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverStrokePathInstancedNV) ID() binary.ID {
	return binaryIDGlCoverStrokePathInstancedNV
}
func (*binaryClassGlCoverStrokePathInstancedNV) New() binary.Object {
	return &GlCoverStrokePathInstancedNV{}
}
func (*binaryClassGlCoverStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverStrokePathInstancedNV(e, obj.(*GlCoverStrokePathInstancedNV))
}
func (*binaryClassGlCoverStrokePathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverStrokePathInstancedNV{}
	return obj, doDecodeGlCoverStrokePathInstancedNV(d, obj)
}
func (*binaryClassGlCoverStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverStrokePathInstancedNV(d, obj.(*GlCoverStrokePathInstancedNV))
}
func (*binaryClassGlCoverStrokePathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverStrokePathInstancedNV(d)
}
func (*binaryClassGlCoverStrokePathInstancedNV) Schema() *schema.Class {
	return schemaGlCoverStrokePathInstancedNV
}

var schemaGlCoverStrokePathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlCoverStrokePathInstancedNV,
	Package: "gles",
	Name:    "GlCoverStrokePathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCoverStrokePathNV struct{}

func (*GlCoverStrokePathNV) Class() binary.Class {
	return (*binaryClassGlCoverStrokePathNV)(nil)
}
func doEncodeGlCoverStrokePathNV(e binary.Encoder, o *GlCoverStrokePathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverStrokePathNV(d binary.Decoder, o *GlCoverStrokePathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	return nil
}
func doSkipGlCoverStrokePathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverStrokePathNV) ID() binary.ID      { return binaryIDGlCoverStrokePathNV }
func (*binaryClassGlCoverStrokePathNV) New() binary.Object { return &GlCoverStrokePathNV{} }
func (*binaryClassGlCoverStrokePathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverStrokePathNV(e, obj.(*GlCoverStrokePathNV))
}
func (*binaryClassGlCoverStrokePathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverStrokePathNV{}
	return obj, doDecodeGlCoverStrokePathNV(d, obj)
}
func (*binaryClassGlCoverStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverStrokePathNV(d, obj.(*GlCoverStrokePathNV))
}
func (*binaryClassGlCoverStrokePathNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverStrokePathNV(d)
}
func (*binaryClassGlCoverStrokePathNV) Schema() *schema.Class { return schemaGlCoverStrokePathNV }

var schemaGlCoverStrokePathNV = &schema.Class{
	TypeID:  binaryIDGlCoverStrokePathNV,
	Package: "gles",
	Name:    "GlCoverStrokePathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlCoverageMaskNV struct{}

func (*GlCoverageMaskNV) Class() binary.Class {
	return (*binaryClassGlCoverageMaskNV)(nil)
}
func doEncodeGlCoverageMaskNV(e binary.Encoder, o *GlCoverageMaskNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverageMaskNV(d binary.Decoder, o *GlCoverageMaskNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Mask = GLboolean(obj)
	}
	return nil
}
func doSkipGlCoverageMaskNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverageMaskNV) ID() binary.ID      { return binaryIDGlCoverageMaskNV }
func (*binaryClassGlCoverageMaskNV) New() binary.Object { return &GlCoverageMaskNV{} }
func (*binaryClassGlCoverageMaskNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverageMaskNV(e, obj.(*GlCoverageMaskNV))
}
func (*binaryClassGlCoverageMaskNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverageMaskNV{}
	return obj, doDecodeGlCoverageMaskNV(d, obj)
}
func (*binaryClassGlCoverageMaskNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverageMaskNV(d, obj.(*GlCoverageMaskNV))
}
func (*binaryClassGlCoverageMaskNV) Skip(d binary.Decoder) error { return doSkipGlCoverageMaskNV(d) }
func (*binaryClassGlCoverageMaskNV) Schema() *schema.Class       { return schemaGlCoverageMaskNV }

var schemaGlCoverageMaskNV = &schema.Class{
	TypeID:  binaryIDGlCoverageMaskNV,
	Package: "gles",
	Name:    "GlCoverageMaskNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlCoverageModulationNV struct{}

func (*GlCoverageModulationNV) Class() binary.Class {
	return (*binaryClassGlCoverageModulationNV)(nil)
}
func doEncodeGlCoverageModulationNV(e binary.Encoder, o *GlCoverageModulationNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Components)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverageModulationNV(d binary.Decoder, o *GlCoverageModulationNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Components = GLenum(obj)
	}
	return nil
}
func doSkipGlCoverageModulationNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverageModulationNV) ID() binary.ID      { return binaryIDGlCoverageModulationNV }
func (*binaryClassGlCoverageModulationNV) New() binary.Object { return &GlCoverageModulationNV{} }
func (*binaryClassGlCoverageModulationNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverageModulationNV(e, obj.(*GlCoverageModulationNV))
}
func (*binaryClassGlCoverageModulationNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverageModulationNV{}
	return obj, doDecodeGlCoverageModulationNV(d, obj)
}
func (*binaryClassGlCoverageModulationNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverageModulationNV(d, obj.(*GlCoverageModulationNV))
}
func (*binaryClassGlCoverageModulationNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverageModulationNV(d)
}
func (*binaryClassGlCoverageModulationNV) Schema() *schema.Class { return schemaGlCoverageModulationNV }

var schemaGlCoverageModulationNV = &schema.Class{
	TypeID:  binaryIDGlCoverageModulationNV,
	Package: "gles",
	Name:    "GlCoverageModulationNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Components", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlCoverageModulationTableNV struct{}

func (*GlCoverageModulationTableNV) Class() binary.Class {
	return (*binaryClassGlCoverageModulationTableNV)(nil)
}
func doEncodeGlCoverageModulationTableNV(e binary.Encoder, o *GlCoverageModulationTableNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverageModulationTableNV(d binary.Decoder, o *GlCoverageModulationTableNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlCoverageModulationTableNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverageModulationTableNV) ID() binary.ID {
	return binaryIDGlCoverageModulationTableNV
}
func (*binaryClassGlCoverageModulationTableNV) New() binary.Object {
	return &GlCoverageModulationTableNV{}
}
func (*binaryClassGlCoverageModulationTableNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverageModulationTableNV(e, obj.(*GlCoverageModulationTableNV))
}
func (*binaryClassGlCoverageModulationTableNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverageModulationTableNV{}
	return obj, doDecodeGlCoverageModulationTableNV(d, obj)
}
func (*binaryClassGlCoverageModulationTableNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverageModulationTableNV(d, obj.(*GlCoverageModulationTableNV))
}
func (*binaryClassGlCoverageModulationTableNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverageModulationTableNV(d)
}
func (*binaryClassGlCoverageModulationTableNV) Schema() *schema.Class {
	return schemaGlCoverageModulationTableNV
}

var schemaGlCoverageModulationTableNV = &schema.Class{
	TypeID:  binaryIDGlCoverageModulationTableNV,
	Package: "gles",
	Name:    "GlCoverageModulationTableNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCoverageOperationNV struct{}

func (*GlCoverageOperationNV) Class() binary.Class {
	return (*binaryClassGlCoverageOperationNV)(nil)
}
func doEncodeGlCoverageOperationNV(e binary.Encoder, o *GlCoverageOperationNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Operation)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCoverageOperationNV(d binary.Decoder, o *GlCoverageOperationNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Operation = GLenum(obj)
	}
	return nil
}
func doSkipGlCoverageOperationNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCoverageOperationNV) ID() binary.ID      { return binaryIDGlCoverageOperationNV }
func (*binaryClassGlCoverageOperationNV) New() binary.Object { return &GlCoverageOperationNV{} }
func (*binaryClassGlCoverageOperationNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCoverageOperationNV(e, obj.(*GlCoverageOperationNV))
}
func (*binaryClassGlCoverageOperationNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCoverageOperationNV{}
	return obj, doDecodeGlCoverageOperationNV(d, obj)
}
func (*binaryClassGlCoverageOperationNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCoverageOperationNV(d, obj.(*GlCoverageOperationNV))
}
func (*binaryClassGlCoverageOperationNV) Skip(d binary.Decoder) error {
	return doSkipGlCoverageOperationNV(d)
}
func (*binaryClassGlCoverageOperationNV) Schema() *schema.Class { return schemaGlCoverageOperationNV }

var schemaGlCoverageOperationNV = &schema.Class{
	TypeID:  binaryIDGlCoverageOperationNV,
	Package: "gles",
	Name:    "GlCoverageOperationNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Operation", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlCreatePerfQueryINTEL struct{}

func (*GlCreatePerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlCreatePerfQueryINTEL)(nil)
}
func doEncodeGlCreatePerfQueryINTEL(e binary.Encoder, o *GlCreatePerfQueryINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryId)); err != nil {
		return err
	}
	if err := e.Value(&o.QueryHandle); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCreatePerfQueryINTEL(d binary.Decoder, o *GlCreatePerfQueryINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryId = GLuint(obj)
	}
	if err := d.Value(&o.QueryHandle); err != nil {
		return err
	}
	return nil
}
func doSkipGlCreatePerfQueryINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCreatePerfQueryINTEL) ID() binary.ID      { return binaryIDGlCreatePerfQueryINTEL }
func (*binaryClassGlCreatePerfQueryINTEL) New() binary.Object { return &GlCreatePerfQueryINTEL{} }
func (*binaryClassGlCreatePerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCreatePerfQueryINTEL(e, obj.(*GlCreatePerfQueryINTEL))
}
func (*binaryClassGlCreatePerfQueryINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCreatePerfQueryINTEL{}
	return obj, doDecodeGlCreatePerfQueryINTEL(d, obj)
}
func (*binaryClassGlCreatePerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCreatePerfQueryINTEL(d, obj.(*GlCreatePerfQueryINTEL))
}
func (*binaryClassGlCreatePerfQueryINTEL) Skip(d binary.Decoder) error {
	return doSkipGlCreatePerfQueryINTEL(d)
}
func (*binaryClassGlCreatePerfQueryINTEL) Schema() *schema.Class { return schemaGlCreatePerfQueryINTEL }

var schemaGlCreatePerfQueryINTEL = &schema.Class{
	TypeID:  binaryIDGlCreatePerfQueryINTEL,
	Package: "gles",
	Name:    "GlCreatePerfQueryINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "QueryHandle", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlCreateProgram struct{}

func (*GlCreateProgram) Class() binary.Class {
	return (*binaryClassGlCreateProgram)(nil)
}
func doEncodeGlCreateProgram(e binary.Encoder, o *GlCreateProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCreateProgram(d binary.Decoder, o *GlCreateProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = ProgramId(obj)
	}
	return nil
}
func doSkipGlCreateProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCreateProgram) ID() binary.ID      { return binaryIDGlCreateProgram }
func (*binaryClassGlCreateProgram) New() binary.Object { return &GlCreateProgram{} }
func (*binaryClassGlCreateProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCreateProgram(e, obj.(*GlCreateProgram))
}
func (*binaryClassGlCreateProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCreateProgram{}
	return obj, doDecodeGlCreateProgram(d, obj)
}
func (*binaryClassGlCreateProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCreateProgram(d, obj.(*GlCreateProgram))
}
func (*binaryClassGlCreateProgram) Skip(d binary.Decoder) error { return doSkipGlCreateProgram(d) }
func (*binaryClassGlCreateProgram) Schema() *schema.Class       { return schemaGlCreateProgram }

var schemaGlCreateProgram = &schema.Class{
	TypeID:  binaryIDGlCreateProgram,
	Package: "gles",
	Name:    "GlCreateProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlCreateShader struct{}

func (*GlCreateShader) Class() binary.Class {
	return (*binaryClassGlCreateShader)(nil)
}
func doEncodeGlCreateShader(e binary.Encoder, o *GlCreateShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCreateShader(d binary.Decoder, o *GlCreateShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = ShaderId(obj)
	}
	return nil
}
func doSkipGlCreateShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCreateShader) ID() binary.ID      { return binaryIDGlCreateShader }
func (*binaryClassGlCreateShader) New() binary.Object { return &GlCreateShader{} }
func (*binaryClassGlCreateShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCreateShader(e, obj.(*GlCreateShader))
}
func (*binaryClassGlCreateShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCreateShader{}
	return obj, doDecodeGlCreateShader(d, obj)
}
func (*binaryClassGlCreateShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCreateShader(d, obj.(*GlCreateShader))
}
func (*binaryClassGlCreateShader) Skip(d binary.Decoder) error { return doSkipGlCreateShader(d) }
func (*binaryClassGlCreateShader) Schema() *schema.Class       { return schemaGlCreateShader }

var schemaGlCreateShader = &schema.Class{
	TypeID:  binaryIDGlCreateShader,
	Package: "gles",
	Name:    "GlCreateShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
	},
}

type binaryClassGlCreateShaderProgramv struct{}

func (*GlCreateShaderProgramv) Class() binary.Class {
	return (*binaryClassGlCreateShaderProgramv)(nil)
}
func doEncodeGlCreateShaderProgramv(e binary.Encoder, o *GlCreateShaderProgramv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Strings); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCreateShaderProgramv(d binary.Decoder, o *GlCreateShaderProgramv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Strings); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = ProgramId(obj)
	}
	return nil
}
func doSkipGlCreateShaderProgramv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCreateShaderProgramv) ID() binary.ID      { return binaryIDGlCreateShaderProgramv }
func (*binaryClassGlCreateShaderProgramv) New() binary.Object { return &GlCreateShaderProgramv{} }
func (*binaryClassGlCreateShaderProgramv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCreateShaderProgramv(e, obj.(*GlCreateShaderProgramv))
}
func (*binaryClassGlCreateShaderProgramv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCreateShaderProgramv{}
	return obj, doDecodeGlCreateShaderProgramv(d, obj)
}
func (*binaryClassGlCreateShaderProgramv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCreateShaderProgramv(d, obj.(*GlCreateShaderProgramv))
}
func (*binaryClassGlCreateShaderProgramv) Skip(d binary.Decoder) error {
	return doSkipGlCreateShaderProgramv(d)
}
func (*binaryClassGlCreateShaderProgramv) Schema() *schema.Class { return schemaGlCreateShaderProgramv }

var schemaGlCreateShaderProgramv = &schema.Class{
	TypeID:  binaryIDGlCreateShaderProgramv,
	Package: "gles",
	Name:    "GlCreateShaderProgramv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Strings", Type: &schema.Struct{Name: "GLcharᶜᵖᶜᵖ", ID: (*GLcharᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlCreateShaderProgramvEXT struct{}

func (*GlCreateShaderProgramvEXT) Class() binary.Class {
	return (*binaryClassGlCreateShaderProgramvEXT)(nil)
}
func doEncodeGlCreateShaderProgramvEXT(e binary.Encoder, o *GlCreateShaderProgramvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Strings); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCreateShaderProgramvEXT(d binary.Decoder, o *GlCreateShaderProgramvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Strings); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLuint(obj)
	}
	return nil
}
func doSkipGlCreateShaderProgramvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCreateShaderProgramvEXT) ID() binary.ID      { return binaryIDGlCreateShaderProgramvEXT }
func (*binaryClassGlCreateShaderProgramvEXT) New() binary.Object { return &GlCreateShaderProgramvEXT{} }
func (*binaryClassGlCreateShaderProgramvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCreateShaderProgramvEXT(e, obj.(*GlCreateShaderProgramvEXT))
}
func (*binaryClassGlCreateShaderProgramvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCreateShaderProgramvEXT{}
	return obj, doDecodeGlCreateShaderProgramvEXT(d, obj)
}
func (*binaryClassGlCreateShaderProgramvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCreateShaderProgramvEXT(d, obj.(*GlCreateShaderProgramvEXT))
}
func (*binaryClassGlCreateShaderProgramvEXT) Skip(d binary.Decoder) error {
	return doSkipGlCreateShaderProgramvEXT(d)
}
func (*binaryClassGlCreateShaderProgramvEXT) Schema() *schema.Class {
	return schemaGlCreateShaderProgramvEXT
}

var schemaGlCreateShaderProgramvEXT = &schema.Class{
	TypeID:  binaryIDGlCreateShaderProgramvEXT,
	Package: "gles",
	Name:    "GlCreateShaderProgramvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Strings", Type: &schema.Struct{Name: "GLcharᶜᵖᵖ", ID: (*GLcharᶜᵖᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlCullFace struct{}

func (*GlCullFace) Class() binary.Class {
	return (*binaryClassGlCullFace)(nil)
}
func doEncodeGlCullFace(e binary.Encoder, o *GlCullFace) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlCullFace(d binary.Decoder, o *GlCullFace) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlCullFace(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlCullFace) ID() binary.ID      { return binaryIDGlCullFace }
func (*binaryClassGlCullFace) New() binary.Object { return &GlCullFace{} }
func (*binaryClassGlCullFace) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlCullFace(e, obj.(*GlCullFace))
}
func (*binaryClassGlCullFace) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlCullFace{}
	return obj, doDecodeGlCullFace(d, obj)
}
func (*binaryClassGlCullFace) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlCullFace(d, obj.(*GlCullFace))
}
func (*binaryClassGlCullFace) Skip(d binary.Decoder) error { return doSkipGlCullFace(d) }
func (*binaryClassGlCullFace) Schema() *schema.Class       { return schemaGlCullFace }

var schemaGlCullFace = &schema.Class{
	TypeID:  binaryIDGlCullFace,
	Package: "gles",
	Name:    "GlCullFace",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlDebugMessageCallbackKHR struct{}

func (*GlDebugMessageCallbackKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageCallbackKHR)(nil)
}
func doEncodeGlDebugMessageCallbackKHR(e binary.Encoder, o *GlDebugMessageCallbackKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Callback); err != nil {
		return err
	}
	if err := e.Value(&o.UserParam); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDebugMessageCallbackKHR(d binary.Decoder, o *GlDebugMessageCallbackKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Callback); err != nil {
		return err
	}
	if err := d.Value(&o.UserParam); err != nil {
		return err
	}
	return nil
}
func doSkipGlDebugMessageCallbackKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLDEBUGPROCKHR)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDebugMessageCallbackKHR) ID() binary.ID      { return binaryIDGlDebugMessageCallbackKHR }
func (*binaryClassGlDebugMessageCallbackKHR) New() binary.Object { return &GlDebugMessageCallbackKHR{} }
func (*binaryClassGlDebugMessageCallbackKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDebugMessageCallbackKHR(e, obj.(*GlDebugMessageCallbackKHR))
}
func (*binaryClassGlDebugMessageCallbackKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDebugMessageCallbackKHR{}
	return obj, doDecodeGlDebugMessageCallbackKHR(d, obj)
}
func (*binaryClassGlDebugMessageCallbackKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDebugMessageCallbackKHR(d, obj.(*GlDebugMessageCallbackKHR))
}
func (*binaryClassGlDebugMessageCallbackKHR) Skip(d binary.Decoder) error {
	return doSkipGlDebugMessageCallbackKHR(d)
}
func (*binaryClassGlDebugMessageCallbackKHR) Schema() *schema.Class {
	return schemaGlDebugMessageCallbackKHR
}

var schemaGlDebugMessageCallbackKHR = &schema.Class{
	TypeID:  binaryIDGlDebugMessageCallbackKHR,
	Package: "gles",
	Name:    "GlDebugMessageCallbackKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Callback", Type: &schema.Struct{Name: "GLDEBUGPROCKHR", ID: (*GLDEBUGPROCKHR)(nil).Class().ID()}},
		{Declared: "UserParam", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDebugMessageControlKHR struct{}

func (*GlDebugMessageControlKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageControlKHR)(nil)
}
func doEncodeGlDebugMessageControlKHR(e binary.Encoder, o *GlDebugMessageControlKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Source)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Severity)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Ids); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Enabled)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDebugMessageControlKHR(d binary.Decoder, o *GlDebugMessageControlKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Source = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Severity = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Ids); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Enabled = GLboolean(obj)
	}
	return nil
}
func doSkipGlDebugMessageControlKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDebugMessageControlKHR) ID() binary.ID      { return binaryIDGlDebugMessageControlKHR }
func (*binaryClassGlDebugMessageControlKHR) New() binary.Object { return &GlDebugMessageControlKHR{} }
func (*binaryClassGlDebugMessageControlKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDebugMessageControlKHR(e, obj.(*GlDebugMessageControlKHR))
}
func (*binaryClassGlDebugMessageControlKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDebugMessageControlKHR{}
	return obj, doDecodeGlDebugMessageControlKHR(d, obj)
}
func (*binaryClassGlDebugMessageControlKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDebugMessageControlKHR(d, obj.(*GlDebugMessageControlKHR))
}
func (*binaryClassGlDebugMessageControlKHR) Skip(d binary.Decoder) error {
	return doSkipGlDebugMessageControlKHR(d)
}
func (*binaryClassGlDebugMessageControlKHR) Schema() *schema.Class {
	return schemaGlDebugMessageControlKHR
}

var schemaGlDebugMessageControlKHR = &schema.Class{
	TypeID:  binaryIDGlDebugMessageControlKHR,
	Package: "gles",
	Name:    "GlDebugMessageControlKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Severity", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Ids", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
		{Declared: "Enabled", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlDebugMessageInsertKHR struct{}

func (*GlDebugMessageInsertKHR) Class() binary.Class {
	return (*binaryClassGlDebugMessageInsertKHR)(nil)
}
func doEncodeGlDebugMessageInsertKHR(e binary.Encoder, o *GlDebugMessageInsertKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Source)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Id)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Severity)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Buf); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDebugMessageInsertKHR(d binary.Decoder, o *GlDebugMessageInsertKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Source = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Severity = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Buf); err != nil {
		return err
	}
	return nil
}
func doSkipGlDebugMessageInsertKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDebugMessageInsertKHR) ID() binary.ID      { return binaryIDGlDebugMessageInsertKHR }
func (*binaryClassGlDebugMessageInsertKHR) New() binary.Object { return &GlDebugMessageInsertKHR{} }
func (*binaryClassGlDebugMessageInsertKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDebugMessageInsertKHR(e, obj.(*GlDebugMessageInsertKHR))
}
func (*binaryClassGlDebugMessageInsertKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDebugMessageInsertKHR{}
	return obj, doDecodeGlDebugMessageInsertKHR(d, obj)
}
func (*binaryClassGlDebugMessageInsertKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDebugMessageInsertKHR(d, obj.(*GlDebugMessageInsertKHR))
}
func (*binaryClassGlDebugMessageInsertKHR) Skip(d binary.Decoder) error {
	return doSkipGlDebugMessageInsertKHR(d)
}
func (*binaryClassGlDebugMessageInsertKHR) Schema() *schema.Class {
	return schemaGlDebugMessageInsertKHR
}

var schemaGlDebugMessageInsertKHR = &schema.Class{
	TypeID:  binaryIDGlDebugMessageInsertKHR,
	Package: "gles",
	Name:    "GlDebugMessageInsertKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Id", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Severity", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Buf", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteBuffers struct{}

func (*GlDeleteBuffers) Class() binary.Class {
	return (*binaryClassGlDeleteBuffers)(nil)
}
func doEncodeGlDeleteBuffers(e binary.Encoder, o *GlDeleteBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Buffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteBuffers(d binary.Decoder, o *GlDeleteBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Buffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BufferIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteBuffers) ID() binary.ID      { return binaryIDGlDeleteBuffers }
func (*binaryClassGlDeleteBuffers) New() binary.Object { return &GlDeleteBuffers{} }
func (*binaryClassGlDeleteBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteBuffers(e, obj.(*GlDeleteBuffers))
}
func (*binaryClassGlDeleteBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteBuffers{}
	return obj, doDecodeGlDeleteBuffers(d, obj)
}
func (*binaryClassGlDeleteBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteBuffers(d, obj.(*GlDeleteBuffers))
}
func (*binaryClassGlDeleteBuffers) Skip(d binary.Decoder) error { return doSkipGlDeleteBuffers(d) }
func (*binaryClassGlDeleteBuffers) Schema() *schema.Class       { return schemaGlDeleteBuffers }

var schemaGlDeleteBuffers = &schema.Class{
	TypeID:  binaryIDGlDeleteBuffers,
	Package: "gles",
	Name:    "GlDeleteBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Buffers", Type: &schema.Struct{Name: "BufferIdᶜᵖ", ID: (*BufferIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteFencesNV struct{}

func (*GlDeleteFencesNV) Class() binary.Class {
	return (*binaryClassGlDeleteFencesNV)(nil)
}
func doEncodeGlDeleteFencesNV(e binary.Encoder, o *GlDeleteFencesNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Fences); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteFencesNV(d binary.Decoder, o *GlDeleteFencesNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Fences); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteFencesNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteFencesNV) ID() binary.ID      { return binaryIDGlDeleteFencesNV }
func (*binaryClassGlDeleteFencesNV) New() binary.Object { return &GlDeleteFencesNV{} }
func (*binaryClassGlDeleteFencesNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteFencesNV(e, obj.(*GlDeleteFencesNV))
}
func (*binaryClassGlDeleteFencesNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteFencesNV{}
	return obj, doDecodeGlDeleteFencesNV(d, obj)
}
func (*binaryClassGlDeleteFencesNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteFencesNV(d, obj.(*GlDeleteFencesNV))
}
func (*binaryClassGlDeleteFencesNV) Skip(d binary.Decoder) error { return doSkipGlDeleteFencesNV(d) }
func (*binaryClassGlDeleteFencesNV) Schema() *schema.Class       { return schemaGlDeleteFencesNV }

var schemaGlDeleteFencesNV = &schema.Class{
	TypeID:  binaryIDGlDeleteFencesNV,
	Package: "gles",
	Name:    "GlDeleteFencesNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Fences", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteFramebuffers struct{}

func (*GlDeleteFramebuffers) Class() binary.Class {
	return (*binaryClassGlDeleteFramebuffers)(nil)
}
func doEncodeGlDeleteFramebuffers(e binary.Encoder, o *GlDeleteFramebuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Framebuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteFramebuffers(d binary.Decoder, o *GlDeleteFramebuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Framebuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteFramebuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*FramebufferIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteFramebuffers) ID() binary.ID      { return binaryIDGlDeleteFramebuffers }
func (*binaryClassGlDeleteFramebuffers) New() binary.Object { return &GlDeleteFramebuffers{} }
func (*binaryClassGlDeleteFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteFramebuffers(e, obj.(*GlDeleteFramebuffers))
}
func (*binaryClassGlDeleteFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteFramebuffers{}
	return obj, doDecodeGlDeleteFramebuffers(d, obj)
}
func (*binaryClassGlDeleteFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteFramebuffers(d, obj.(*GlDeleteFramebuffers))
}
func (*binaryClassGlDeleteFramebuffers) Skip(d binary.Decoder) error {
	return doSkipGlDeleteFramebuffers(d)
}
func (*binaryClassGlDeleteFramebuffers) Schema() *schema.Class { return schemaGlDeleteFramebuffers }

var schemaGlDeleteFramebuffers = &schema.Class{
	TypeID:  binaryIDGlDeleteFramebuffers,
	Package: "gles",
	Name:    "GlDeleteFramebuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Framebuffers", Type: &schema.Struct{Name: "FramebufferIdᶜᵖ", ID: (*FramebufferIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeletePathsNV struct{}

func (*GlDeletePathsNV) Class() binary.Class {
	return (*binaryClassGlDeletePathsNV)(nil)
}
func doEncodeGlDeletePathsNV(e binary.Encoder, o *GlDeletePathsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Range)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeletePathsNV(d binary.Decoder, o *GlDeletePathsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Range = GLsizei(obj)
	}
	return nil
}
func doSkipGlDeletePathsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeletePathsNV) ID() binary.ID      { return binaryIDGlDeletePathsNV }
func (*binaryClassGlDeletePathsNV) New() binary.Object { return &GlDeletePathsNV{} }
func (*binaryClassGlDeletePathsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeletePathsNV(e, obj.(*GlDeletePathsNV))
}
func (*binaryClassGlDeletePathsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeletePathsNV{}
	return obj, doDecodeGlDeletePathsNV(d, obj)
}
func (*binaryClassGlDeletePathsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeletePathsNV(d, obj.(*GlDeletePathsNV))
}
func (*binaryClassGlDeletePathsNV) Skip(d binary.Decoder) error { return doSkipGlDeletePathsNV(d) }
func (*binaryClassGlDeletePathsNV) Schema() *schema.Class       { return schemaGlDeletePathsNV }

var schemaGlDeletePathsNV = &schema.Class{
	TypeID:  binaryIDGlDeletePathsNV,
	Package: "gles",
	Name:    "GlDeletePathsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Range", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDeletePerfMonitorsAMD struct{}

func (*GlDeletePerfMonitorsAMD) Class() binary.Class {
	return (*binaryClassGlDeletePerfMonitorsAMD)(nil)
}
func doEncodeGlDeletePerfMonitorsAMD(e binary.Encoder, o *GlDeletePerfMonitorsAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Monitors); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeletePerfMonitorsAMD(d binary.Decoder, o *GlDeletePerfMonitorsAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Monitors); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeletePerfMonitorsAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeletePerfMonitorsAMD) ID() binary.ID      { return binaryIDGlDeletePerfMonitorsAMD }
func (*binaryClassGlDeletePerfMonitorsAMD) New() binary.Object { return &GlDeletePerfMonitorsAMD{} }
func (*binaryClassGlDeletePerfMonitorsAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeletePerfMonitorsAMD(e, obj.(*GlDeletePerfMonitorsAMD))
}
func (*binaryClassGlDeletePerfMonitorsAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeletePerfMonitorsAMD{}
	return obj, doDecodeGlDeletePerfMonitorsAMD(d, obj)
}
func (*binaryClassGlDeletePerfMonitorsAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeletePerfMonitorsAMD(d, obj.(*GlDeletePerfMonitorsAMD))
}
func (*binaryClassGlDeletePerfMonitorsAMD) Skip(d binary.Decoder) error {
	return doSkipGlDeletePerfMonitorsAMD(d)
}
func (*binaryClassGlDeletePerfMonitorsAMD) Schema() *schema.Class {
	return schemaGlDeletePerfMonitorsAMD
}

var schemaGlDeletePerfMonitorsAMD = &schema.Class{
	TypeID:  binaryIDGlDeletePerfMonitorsAMD,
	Package: "gles",
	Name:    "GlDeletePerfMonitorsAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Monitors", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeletePerfQueryINTEL struct{}

func (*GlDeletePerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlDeletePerfQueryINTEL)(nil)
}
func doEncodeGlDeletePerfQueryINTEL(e binary.Encoder, o *GlDeletePerfQueryINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryHandle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeletePerfQueryINTEL(d binary.Decoder, o *GlDeletePerfQueryINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryHandle = GLuint(obj)
	}
	return nil
}
func doSkipGlDeletePerfQueryINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeletePerfQueryINTEL) ID() binary.ID      { return binaryIDGlDeletePerfQueryINTEL }
func (*binaryClassGlDeletePerfQueryINTEL) New() binary.Object { return &GlDeletePerfQueryINTEL{} }
func (*binaryClassGlDeletePerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeletePerfQueryINTEL(e, obj.(*GlDeletePerfQueryINTEL))
}
func (*binaryClassGlDeletePerfQueryINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeletePerfQueryINTEL{}
	return obj, doDecodeGlDeletePerfQueryINTEL(d, obj)
}
func (*binaryClassGlDeletePerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeletePerfQueryINTEL(d, obj.(*GlDeletePerfQueryINTEL))
}
func (*binaryClassGlDeletePerfQueryINTEL) Skip(d binary.Decoder) error {
	return doSkipGlDeletePerfQueryINTEL(d)
}
func (*binaryClassGlDeletePerfQueryINTEL) Schema() *schema.Class { return schemaGlDeletePerfQueryINTEL }

var schemaGlDeletePerfQueryINTEL = &schema.Class{
	TypeID:  binaryIDGlDeletePerfQueryINTEL,
	Package: "gles",
	Name:    "GlDeletePerfQueryINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryHandle", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDeleteProgram struct{}

func (*GlDeleteProgram) Class() binary.Class {
	return (*binaryClassGlDeleteProgram)(nil)
}
func doEncodeGlDeleteProgram(e binary.Encoder, o *GlDeleteProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteProgram(d binary.Decoder, o *GlDeleteProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlDeleteProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteProgram) ID() binary.ID      { return binaryIDGlDeleteProgram }
func (*binaryClassGlDeleteProgram) New() binary.Object { return &GlDeleteProgram{} }
func (*binaryClassGlDeleteProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteProgram(e, obj.(*GlDeleteProgram))
}
func (*binaryClassGlDeleteProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteProgram{}
	return obj, doDecodeGlDeleteProgram(d, obj)
}
func (*binaryClassGlDeleteProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteProgram(d, obj.(*GlDeleteProgram))
}
func (*binaryClassGlDeleteProgram) Skip(d binary.Decoder) error { return doSkipGlDeleteProgram(d) }
func (*binaryClassGlDeleteProgram) Schema() *schema.Class       { return schemaGlDeleteProgram }

var schemaGlDeleteProgram = &schema.Class{
	TypeID:  binaryIDGlDeleteProgram,
	Package: "gles",
	Name:    "GlDeleteProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassPipelineIdᶜᵖ struct{}

func (*PipelineIdᶜᵖ) Class() binary.Class {
	return (*binaryClassPipelineIdᶜᵖ)(nil)
}
func doEncodePipelineIdᶜᵖ(e binary.Encoder, o *PipelineIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodePipelineIdᶜᵖ(d binary.Decoder, o *PipelineIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipPipelineIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassPipelineIdᶜᵖ) ID() binary.ID      { return binaryIDPipelineIdᶜᵖ }
func (*binaryClassPipelineIdᶜᵖ) New() binary.Object { return &PipelineIdᶜᵖ{} }
func (*binaryClassPipelineIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodePipelineIdᶜᵖ(e, obj.(*PipelineIdᶜᵖ))
}
func (*binaryClassPipelineIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &PipelineIdᶜᵖ{}
	return obj, doDecodePipelineIdᶜᵖ(d, obj)
}
func (*binaryClassPipelineIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodePipelineIdᶜᵖ(d, obj.(*PipelineIdᶜᵖ))
}
func (*binaryClassPipelineIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipPipelineIdᶜᵖ(d) }
func (*binaryClassPipelineIdᶜᵖ) Schema() *schema.Class       { return schemaPipelineIdᶜᵖ }

var schemaPipelineIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDPipelineIdᶜᵖ,
	Package: "gles",
	Name:    "PipelineIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteProgramPipelines struct{}

func (*GlDeleteProgramPipelines) Class() binary.Class {
	return (*binaryClassGlDeleteProgramPipelines)(nil)
}
func doEncodeGlDeleteProgramPipelines(e binary.Encoder, o *GlDeleteProgramPipelines) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteProgramPipelines(d binary.Decoder, o *GlDeleteProgramPipelines) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteProgramPipelines(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*PipelineIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteProgramPipelines) ID() binary.ID      { return binaryIDGlDeleteProgramPipelines }
func (*binaryClassGlDeleteProgramPipelines) New() binary.Object { return &GlDeleteProgramPipelines{} }
func (*binaryClassGlDeleteProgramPipelines) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteProgramPipelines(e, obj.(*GlDeleteProgramPipelines))
}
func (*binaryClassGlDeleteProgramPipelines) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteProgramPipelines{}
	return obj, doDecodeGlDeleteProgramPipelines(d, obj)
}
func (*binaryClassGlDeleteProgramPipelines) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteProgramPipelines(d, obj.(*GlDeleteProgramPipelines))
}
func (*binaryClassGlDeleteProgramPipelines) Skip(d binary.Decoder) error {
	return doSkipGlDeleteProgramPipelines(d)
}
func (*binaryClassGlDeleteProgramPipelines) Schema() *schema.Class {
	return schemaGlDeleteProgramPipelines
}

var schemaGlDeleteProgramPipelines = &schema.Class{
	TypeID:  binaryIDGlDeleteProgramPipelines,
	Package: "gles",
	Name:    "GlDeleteProgramPipelines",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pipelines", Type: &schema.Struct{Name: "PipelineIdᶜᵖ", ID: (*PipelineIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteProgramPipelinesEXT struct{}

func (*GlDeleteProgramPipelinesEXT) Class() binary.Class {
	return (*binaryClassGlDeleteProgramPipelinesEXT)(nil)
}
func doEncodeGlDeleteProgramPipelinesEXT(e binary.Encoder, o *GlDeleteProgramPipelinesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteProgramPipelinesEXT(d binary.Decoder, o *GlDeleteProgramPipelinesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteProgramPipelinesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*PipelineIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteProgramPipelinesEXT) ID() binary.ID {
	return binaryIDGlDeleteProgramPipelinesEXT
}
func (*binaryClassGlDeleteProgramPipelinesEXT) New() binary.Object {
	return &GlDeleteProgramPipelinesEXT{}
}
func (*binaryClassGlDeleteProgramPipelinesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteProgramPipelinesEXT(e, obj.(*GlDeleteProgramPipelinesEXT))
}
func (*binaryClassGlDeleteProgramPipelinesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteProgramPipelinesEXT{}
	return obj, doDecodeGlDeleteProgramPipelinesEXT(d, obj)
}
func (*binaryClassGlDeleteProgramPipelinesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteProgramPipelinesEXT(d, obj.(*GlDeleteProgramPipelinesEXT))
}
func (*binaryClassGlDeleteProgramPipelinesEXT) Skip(d binary.Decoder) error {
	return doSkipGlDeleteProgramPipelinesEXT(d)
}
func (*binaryClassGlDeleteProgramPipelinesEXT) Schema() *schema.Class {
	return schemaGlDeleteProgramPipelinesEXT
}

var schemaGlDeleteProgramPipelinesEXT = &schema.Class{
	TypeID:  binaryIDGlDeleteProgramPipelinesEXT,
	Package: "gles",
	Name:    "GlDeleteProgramPipelinesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pipelines", Type: &schema.Struct{Name: "PipelineIdᶜᵖ", ID: (*PipelineIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassQueryIdᶜᵖ struct{}

func (*QueryIdᶜᵖ) Class() binary.Class {
	return (*binaryClassQueryIdᶜᵖ)(nil)
}
func doEncodeQueryIdᶜᵖ(e binary.Encoder, o *QueryIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeQueryIdᶜᵖ(d binary.Decoder, o *QueryIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipQueryIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassQueryIdᶜᵖ) ID() binary.ID      { return binaryIDQueryIdᶜᵖ }
func (*binaryClassQueryIdᶜᵖ) New() binary.Object { return &QueryIdᶜᵖ{} }
func (*binaryClassQueryIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeQueryIdᶜᵖ(e, obj.(*QueryIdᶜᵖ))
}
func (*binaryClassQueryIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &QueryIdᶜᵖ{}
	return obj, doDecodeQueryIdᶜᵖ(d, obj)
}
func (*binaryClassQueryIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeQueryIdᶜᵖ(d, obj.(*QueryIdᶜᵖ))
}
func (*binaryClassQueryIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipQueryIdᶜᵖ(d) }
func (*binaryClassQueryIdᶜᵖ) Schema() *schema.Class       { return schemaQueryIdᶜᵖ }

var schemaQueryIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDQueryIdᶜᵖ,
	Package: "gles",
	Name:    "QueryIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteQueries struct{}

func (*GlDeleteQueries) Class() binary.Class {
	return (*binaryClassGlDeleteQueries)(nil)
}
func doEncodeGlDeleteQueries(e binary.Encoder, o *GlDeleteQueries) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteQueries(d binary.Decoder, o *GlDeleteQueries) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteQueries(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*QueryIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteQueries) ID() binary.ID      { return binaryIDGlDeleteQueries }
func (*binaryClassGlDeleteQueries) New() binary.Object { return &GlDeleteQueries{} }
func (*binaryClassGlDeleteQueries) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteQueries(e, obj.(*GlDeleteQueries))
}
func (*binaryClassGlDeleteQueries) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteQueries{}
	return obj, doDecodeGlDeleteQueries(d, obj)
}
func (*binaryClassGlDeleteQueries) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteQueries(d, obj.(*GlDeleteQueries))
}
func (*binaryClassGlDeleteQueries) Skip(d binary.Decoder) error { return doSkipGlDeleteQueries(d) }
func (*binaryClassGlDeleteQueries) Schema() *schema.Class       { return schemaGlDeleteQueries }

var schemaGlDeleteQueries = &schema.Class{
	TypeID:  binaryIDGlDeleteQueries,
	Package: "gles",
	Name:    "GlDeleteQueries",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᶜᵖ", ID: (*QueryIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteQueriesEXT struct{}

func (*GlDeleteQueriesEXT) Class() binary.Class {
	return (*binaryClassGlDeleteQueriesEXT)(nil)
}
func doEncodeGlDeleteQueriesEXT(e binary.Encoder, o *GlDeleteQueriesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteQueriesEXT(d binary.Decoder, o *GlDeleteQueriesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteQueriesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*QueryIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteQueriesEXT) ID() binary.ID      { return binaryIDGlDeleteQueriesEXT }
func (*binaryClassGlDeleteQueriesEXT) New() binary.Object { return &GlDeleteQueriesEXT{} }
func (*binaryClassGlDeleteQueriesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteQueriesEXT(e, obj.(*GlDeleteQueriesEXT))
}
func (*binaryClassGlDeleteQueriesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteQueriesEXT{}
	return obj, doDecodeGlDeleteQueriesEXT(d, obj)
}
func (*binaryClassGlDeleteQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteQueriesEXT(d, obj.(*GlDeleteQueriesEXT))
}
func (*binaryClassGlDeleteQueriesEXT) Skip(d binary.Decoder) error { return doSkipGlDeleteQueriesEXT(d) }
func (*binaryClassGlDeleteQueriesEXT) Schema() *schema.Class       { return schemaGlDeleteQueriesEXT }

var schemaGlDeleteQueriesEXT = &schema.Class{
	TypeID:  binaryIDGlDeleteQueriesEXT,
	Package: "gles",
	Name:    "GlDeleteQueriesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᶜᵖ", ID: (*QueryIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassRenderbufferIdᶜᵖ struct{}

func (*RenderbufferIdᶜᵖ) Class() binary.Class {
	return (*binaryClassRenderbufferIdᶜᵖ)(nil)
}
func doEncodeRenderbufferIdᶜᵖ(e binary.Encoder, o *RenderbufferIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderbufferIdᶜᵖ(d binary.Decoder, o *RenderbufferIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipRenderbufferIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderbufferIdᶜᵖ) ID() binary.ID      { return binaryIDRenderbufferIdᶜᵖ }
func (*binaryClassRenderbufferIdᶜᵖ) New() binary.Object { return &RenderbufferIdᶜᵖ{} }
func (*binaryClassRenderbufferIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderbufferIdᶜᵖ(e, obj.(*RenderbufferIdᶜᵖ))
}
func (*binaryClassRenderbufferIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderbufferIdᶜᵖ{}
	return obj, doDecodeRenderbufferIdᶜᵖ(d, obj)
}
func (*binaryClassRenderbufferIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderbufferIdᶜᵖ(d, obj.(*RenderbufferIdᶜᵖ))
}
func (*binaryClassRenderbufferIdᶜᵖ) Skip(d binary.Decoder) error {
	return doSkipRenderbufferIdᶜᵖ(d)
}
func (*binaryClassRenderbufferIdᶜᵖ) Schema() *schema.Class { return schemaRenderbufferIdᶜᵖ }

var schemaRenderbufferIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDRenderbufferIdᶜᵖ,
	Package: "gles",
	Name:    "RenderbufferIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteRenderbuffers struct{}

func (*GlDeleteRenderbuffers) Class() binary.Class {
	return (*binaryClassGlDeleteRenderbuffers)(nil)
}
func doEncodeGlDeleteRenderbuffers(e binary.Encoder, o *GlDeleteRenderbuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Renderbuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteRenderbuffers(d binary.Decoder, o *GlDeleteRenderbuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Renderbuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteRenderbuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*RenderbufferIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteRenderbuffers) ID() binary.ID      { return binaryIDGlDeleteRenderbuffers }
func (*binaryClassGlDeleteRenderbuffers) New() binary.Object { return &GlDeleteRenderbuffers{} }
func (*binaryClassGlDeleteRenderbuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteRenderbuffers(e, obj.(*GlDeleteRenderbuffers))
}
func (*binaryClassGlDeleteRenderbuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteRenderbuffers{}
	return obj, doDecodeGlDeleteRenderbuffers(d, obj)
}
func (*binaryClassGlDeleteRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteRenderbuffers(d, obj.(*GlDeleteRenderbuffers))
}
func (*binaryClassGlDeleteRenderbuffers) Skip(d binary.Decoder) error {
	return doSkipGlDeleteRenderbuffers(d)
}
func (*binaryClassGlDeleteRenderbuffers) Schema() *schema.Class { return schemaGlDeleteRenderbuffers }

var schemaGlDeleteRenderbuffers = &schema.Class{
	TypeID:  binaryIDGlDeleteRenderbuffers,
	Package: "gles",
	Name:    "GlDeleteRenderbuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Renderbuffers", Type: &schema.Struct{Name: "RenderbufferIdᶜᵖ", ID: (*RenderbufferIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassSamplerIdᶜᵖ struct{}

func (*SamplerIdᶜᵖ) Class() binary.Class {
	return (*binaryClassSamplerIdᶜᵖ)(nil)
}
func doEncodeSamplerIdᶜᵖ(e binary.Encoder, o *SamplerIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeSamplerIdᶜᵖ(d binary.Decoder, o *SamplerIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipSamplerIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSamplerIdᶜᵖ) ID() binary.ID      { return binaryIDSamplerIdᶜᵖ }
func (*binaryClassSamplerIdᶜᵖ) New() binary.Object { return &SamplerIdᶜᵖ{} }
func (*binaryClassSamplerIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSamplerIdᶜᵖ(e, obj.(*SamplerIdᶜᵖ))
}
func (*binaryClassSamplerIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SamplerIdᶜᵖ{}
	return obj, doDecodeSamplerIdᶜᵖ(d, obj)
}
func (*binaryClassSamplerIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSamplerIdᶜᵖ(d, obj.(*SamplerIdᶜᵖ))
}
func (*binaryClassSamplerIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipSamplerIdᶜᵖ(d) }
func (*binaryClassSamplerIdᶜᵖ) Schema() *schema.Class       { return schemaSamplerIdᶜᵖ }

var schemaSamplerIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDSamplerIdᶜᵖ,
	Package: "gles",
	Name:    "SamplerIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteSamplers struct{}

func (*GlDeleteSamplers) Class() binary.Class {
	return (*binaryClassGlDeleteSamplers)(nil)
}
func doEncodeGlDeleteSamplers(e binary.Encoder, o *GlDeleteSamplers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Samplers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteSamplers(d binary.Decoder, o *GlDeleteSamplers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Samplers); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteSamplers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*SamplerIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteSamplers) ID() binary.ID      { return binaryIDGlDeleteSamplers }
func (*binaryClassGlDeleteSamplers) New() binary.Object { return &GlDeleteSamplers{} }
func (*binaryClassGlDeleteSamplers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteSamplers(e, obj.(*GlDeleteSamplers))
}
func (*binaryClassGlDeleteSamplers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteSamplers{}
	return obj, doDecodeGlDeleteSamplers(d, obj)
}
func (*binaryClassGlDeleteSamplers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteSamplers(d, obj.(*GlDeleteSamplers))
}
func (*binaryClassGlDeleteSamplers) Skip(d binary.Decoder) error { return doSkipGlDeleteSamplers(d) }
func (*binaryClassGlDeleteSamplers) Schema() *schema.Class       { return schemaGlDeleteSamplers }

var schemaGlDeleteSamplers = &schema.Class{
	TypeID:  binaryIDGlDeleteSamplers,
	Package: "gles",
	Name:    "GlDeleteSamplers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Samplers", Type: &schema.Struct{Name: "SamplerIdᶜᵖ", ID: (*SamplerIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteShader struct{}

func (*GlDeleteShader) Class() binary.Class {
	return (*binaryClassGlDeleteShader)(nil)
}
func doEncodeGlDeleteShader(e binary.Encoder, o *GlDeleteShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteShader(d binary.Decoder, o *GlDeleteShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	return nil
}
func doSkipGlDeleteShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteShader) ID() binary.ID      { return binaryIDGlDeleteShader }
func (*binaryClassGlDeleteShader) New() binary.Object { return &GlDeleteShader{} }
func (*binaryClassGlDeleteShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteShader(e, obj.(*GlDeleteShader))
}
func (*binaryClassGlDeleteShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteShader{}
	return obj, doDecodeGlDeleteShader(d, obj)
}
func (*binaryClassGlDeleteShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteShader(d, obj.(*GlDeleteShader))
}
func (*binaryClassGlDeleteShader) Skip(d binary.Decoder) error { return doSkipGlDeleteShader(d) }
func (*binaryClassGlDeleteShader) Schema() *schema.Class       { return schemaGlDeleteShader }

var schemaGlDeleteShader = &schema.Class{
	TypeID:  binaryIDGlDeleteShader,
	Package: "gles",
	Name:    "GlDeleteShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
	},
}

type binaryClassGlDeleteSync struct{}

func (*GlDeleteSync) Class() binary.Class {
	return (*binaryClassGlDeleteSync)(nil)
}
func doEncodeGlDeleteSync(e binary.Encoder, o *GlDeleteSync) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteSync(d binary.Decoder, o *GlDeleteSync) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	return nil
}
func doSkipGlDeleteSync(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteSync) ID() binary.ID      { return binaryIDGlDeleteSync }
func (*binaryClassGlDeleteSync) New() binary.Object { return &GlDeleteSync{} }
func (*binaryClassGlDeleteSync) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteSync(e, obj.(*GlDeleteSync))
}
func (*binaryClassGlDeleteSync) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteSync{}
	return obj, doDecodeGlDeleteSync(d, obj)
}
func (*binaryClassGlDeleteSync) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteSync(d, obj.(*GlDeleteSync))
}
func (*binaryClassGlDeleteSync) Skip(d binary.Decoder) error { return doSkipGlDeleteSync(d) }
func (*binaryClassGlDeleteSync) Schema() *schema.Class       { return schemaGlDeleteSync }

var schemaGlDeleteSync = &schema.Class{
	TypeID:  binaryIDGlDeleteSync,
	Package: "gles",
	Name:    "GlDeleteSync",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
	},
}

type binaryClassGlDeleteSyncAPPLE struct{}

func (*GlDeleteSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlDeleteSyncAPPLE)(nil)
}
func doEncodeGlDeleteSyncAPPLE(e binary.Encoder, o *GlDeleteSyncAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteSyncAPPLE(d binary.Decoder, o *GlDeleteSyncAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	return nil
}
func doSkipGlDeleteSyncAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteSyncAPPLE) ID() binary.ID      { return binaryIDGlDeleteSyncAPPLE }
func (*binaryClassGlDeleteSyncAPPLE) New() binary.Object { return &GlDeleteSyncAPPLE{} }
func (*binaryClassGlDeleteSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteSyncAPPLE(e, obj.(*GlDeleteSyncAPPLE))
}
func (*binaryClassGlDeleteSyncAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteSyncAPPLE{}
	return obj, doDecodeGlDeleteSyncAPPLE(d, obj)
}
func (*binaryClassGlDeleteSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteSyncAPPLE(d, obj.(*GlDeleteSyncAPPLE))
}
func (*binaryClassGlDeleteSyncAPPLE) Skip(d binary.Decoder) error { return doSkipGlDeleteSyncAPPLE(d) }
func (*binaryClassGlDeleteSyncAPPLE) Schema() *schema.Class       { return schemaGlDeleteSyncAPPLE }

var schemaGlDeleteSyncAPPLE = &schema.Class{
	TypeID:  binaryIDGlDeleteSyncAPPLE,
	Package: "gles",
	Name:    "GlDeleteSyncAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
	},
}

type binaryClassTextureIdᶜᵖ struct{}

func (*TextureIdᶜᵖ) Class() binary.Class {
	return (*binaryClassTextureIdᶜᵖ)(nil)
}
func doEncodeTextureIdᶜᵖ(e binary.Encoder, o *TextureIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeTextureIdᶜᵖ(d binary.Decoder, o *TextureIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipTextureIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTextureIdᶜᵖ) ID() binary.ID      { return binaryIDTextureIdᶜᵖ }
func (*binaryClassTextureIdᶜᵖ) New() binary.Object { return &TextureIdᶜᵖ{} }
func (*binaryClassTextureIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTextureIdᶜᵖ(e, obj.(*TextureIdᶜᵖ))
}
func (*binaryClassTextureIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TextureIdᶜᵖ{}
	return obj, doDecodeTextureIdᶜᵖ(d, obj)
}
func (*binaryClassTextureIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTextureIdᶜᵖ(d, obj.(*TextureIdᶜᵖ))
}
func (*binaryClassTextureIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipTextureIdᶜᵖ(d) }
func (*binaryClassTextureIdᶜᵖ) Schema() *schema.Class       { return schemaTextureIdᶜᵖ }

var schemaTextureIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDTextureIdᶜᵖ,
	Package: "gles",
	Name:    "TextureIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteTextures struct{}

func (*GlDeleteTextures) Class() binary.Class {
	return (*binaryClassGlDeleteTextures)(nil)
}
func doEncodeGlDeleteTextures(e binary.Encoder, o *GlDeleteTextures) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Textures); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteTextures(d binary.Decoder, o *GlDeleteTextures) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Textures); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteTextures(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TextureIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteTextures) ID() binary.ID      { return binaryIDGlDeleteTextures }
func (*binaryClassGlDeleteTextures) New() binary.Object { return &GlDeleteTextures{} }
func (*binaryClassGlDeleteTextures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteTextures(e, obj.(*GlDeleteTextures))
}
func (*binaryClassGlDeleteTextures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteTextures{}
	return obj, doDecodeGlDeleteTextures(d, obj)
}
func (*binaryClassGlDeleteTextures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteTextures(d, obj.(*GlDeleteTextures))
}
func (*binaryClassGlDeleteTextures) Skip(d binary.Decoder) error { return doSkipGlDeleteTextures(d) }
func (*binaryClassGlDeleteTextures) Schema() *schema.Class       { return schemaGlDeleteTextures }

var schemaGlDeleteTextures = &schema.Class{
	TypeID:  binaryIDGlDeleteTextures,
	Package: "gles",
	Name:    "GlDeleteTextures",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Textures", Type: &schema.Struct{Name: "TextureIdᶜᵖ", ID: (*TextureIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassTransformFeedbackIdᶜᵖ struct{}

func (*TransformFeedbackIdᶜᵖ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdᶜᵖ)(nil)
}
func doEncodeTransformFeedbackIdᶜᵖ(e binary.Encoder, o *TransformFeedbackIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeTransformFeedbackIdᶜᵖ(d binary.Decoder, o *TransformFeedbackIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipTransformFeedbackIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTransformFeedbackIdᶜᵖ) ID() binary.ID      { return binaryIDTransformFeedbackIdᶜᵖ }
func (*binaryClassTransformFeedbackIdᶜᵖ) New() binary.Object { return &TransformFeedbackIdᶜᵖ{} }
func (*binaryClassTransformFeedbackIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTransformFeedbackIdᶜᵖ(e, obj.(*TransformFeedbackIdᶜᵖ))
}
func (*binaryClassTransformFeedbackIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TransformFeedbackIdᶜᵖ{}
	return obj, doDecodeTransformFeedbackIdᶜᵖ(d, obj)
}
func (*binaryClassTransformFeedbackIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTransformFeedbackIdᶜᵖ(d, obj.(*TransformFeedbackIdᶜᵖ))
}
func (*binaryClassTransformFeedbackIdᶜᵖ) Skip(d binary.Decoder) error {
	return doSkipTransformFeedbackIdᶜᵖ(d)
}
func (*binaryClassTransformFeedbackIdᶜᵖ) Schema() *schema.Class {
	return schemaTransformFeedbackIdᶜᵖ
}

var schemaTransformFeedbackIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDTransformFeedbackIdᶜᵖ,
	Package: "gles",
	Name:    "TransformFeedbackIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteTransformFeedbacks struct{}

func (*GlDeleteTransformFeedbacks) Class() binary.Class {
	return (*binaryClassGlDeleteTransformFeedbacks)(nil)
}
func doEncodeGlDeleteTransformFeedbacks(e binary.Encoder, o *GlDeleteTransformFeedbacks) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Ids); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteTransformFeedbacks(d binary.Decoder, o *GlDeleteTransformFeedbacks) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Ids); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteTransformFeedbacks(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TransformFeedbackIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteTransformFeedbacks) ID() binary.ID {
	return binaryIDGlDeleteTransformFeedbacks
}
func (*binaryClassGlDeleteTransformFeedbacks) New() binary.Object {
	return &GlDeleteTransformFeedbacks{}
}
func (*binaryClassGlDeleteTransformFeedbacks) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteTransformFeedbacks(e, obj.(*GlDeleteTransformFeedbacks))
}
func (*binaryClassGlDeleteTransformFeedbacks) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteTransformFeedbacks{}
	return obj, doDecodeGlDeleteTransformFeedbacks(d, obj)
}
func (*binaryClassGlDeleteTransformFeedbacks) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteTransformFeedbacks(d, obj.(*GlDeleteTransformFeedbacks))
}
func (*binaryClassGlDeleteTransformFeedbacks) Skip(d binary.Decoder) error {
	return doSkipGlDeleteTransformFeedbacks(d)
}
func (*binaryClassGlDeleteTransformFeedbacks) Schema() *schema.Class {
	return schemaGlDeleteTransformFeedbacks
}

var schemaGlDeleteTransformFeedbacks = &schema.Class{
	TypeID:  binaryIDGlDeleteTransformFeedbacks,
	Package: "gles",
	Name:    "GlDeleteTransformFeedbacks",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Ids", Type: &schema.Struct{Name: "TransformFeedbackIdᶜᵖ", ID: (*TransformFeedbackIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassVertexArrayIdᶜᵖ struct{}

func (*VertexArrayIdᶜᵖ) Class() binary.Class {
	return (*binaryClassVertexArrayIdᶜᵖ)(nil)
}
func doEncodeVertexArrayIdᶜᵖ(e binary.Encoder, o *VertexArrayIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexArrayIdᶜᵖ(d binary.Decoder, o *VertexArrayIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVertexArrayIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexArrayIdᶜᵖ) ID() binary.ID      { return binaryIDVertexArrayIdᶜᵖ }
func (*binaryClassVertexArrayIdᶜᵖ) New() binary.Object { return &VertexArrayIdᶜᵖ{} }
func (*binaryClassVertexArrayIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexArrayIdᶜᵖ(e, obj.(*VertexArrayIdᶜᵖ))
}
func (*binaryClassVertexArrayIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexArrayIdᶜᵖ{}
	return obj, doDecodeVertexArrayIdᶜᵖ(d, obj)
}
func (*binaryClassVertexArrayIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexArrayIdᶜᵖ(d, obj.(*VertexArrayIdᶜᵖ))
}
func (*binaryClassVertexArrayIdᶜᵖ) Skip(d binary.Decoder) error {
	return doSkipVertexArrayIdᶜᵖ(d)
}
func (*binaryClassVertexArrayIdᶜᵖ) Schema() *schema.Class { return schemaVertexArrayIdᶜᵖ }

var schemaVertexArrayIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDVertexArrayIdᶜᵖ,
	Package: "gles",
	Name:    "VertexArrayIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteVertexArrays struct{}

func (*GlDeleteVertexArrays) Class() binary.Class {
	return (*binaryClassGlDeleteVertexArrays)(nil)
}
func doEncodeGlDeleteVertexArrays(e binary.Encoder, o *GlDeleteVertexArrays) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteVertexArrays(d binary.Decoder, o *GlDeleteVertexArrays) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteVertexArrays(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexArrayIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteVertexArrays) ID() binary.ID      { return binaryIDGlDeleteVertexArrays }
func (*binaryClassGlDeleteVertexArrays) New() binary.Object { return &GlDeleteVertexArrays{} }
func (*binaryClassGlDeleteVertexArrays) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteVertexArrays(e, obj.(*GlDeleteVertexArrays))
}
func (*binaryClassGlDeleteVertexArrays) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteVertexArrays{}
	return obj, doDecodeGlDeleteVertexArrays(d, obj)
}
func (*binaryClassGlDeleteVertexArrays) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteVertexArrays(d, obj.(*GlDeleteVertexArrays))
}
func (*binaryClassGlDeleteVertexArrays) Skip(d binary.Decoder) error {
	return doSkipGlDeleteVertexArrays(d)
}
func (*binaryClassGlDeleteVertexArrays) Schema() *schema.Class { return schemaGlDeleteVertexArrays }

var schemaGlDeleteVertexArrays = &schema.Class{
	TypeID:  binaryIDGlDeleteVertexArrays,
	Package: "gles",
	Name:    "GlDeleteVertexArrays",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᶜᵖ", ID: (*VertexArrayIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDeleteVertexArraysOES struct{}

func (*GlDeleteVertexArraysOES) Class() binary.Class {
	return (*binaryClassGlDeleteVertexArraysOES)(nil)
}
func doEncodeGlDeleteVertexArraysOES(e binary.Encoder, o *GlDeleteVertexArraysOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDeleteVertexArraysOES(d binary.Decoder, o *GlDeleteVertexArraysOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doSkipGlDeleteVertexArraysOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexArrayIdᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDeleteVertexArraysOES) ID() binary.ID      { return binaryIDGlDeleteVertexArraysOES }
func (*binaryClassGlDeleteVertexArraysOES) New() binary.Object { return &GlDeleteVertexArraysOES{} }
func (*binaryClassGlDeleteVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDeleteVertexArraysOES(e, obj.(*GlDeleteVertexArraysOES))
}
func (*binaryClassGlDeleteVertexArraysOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDeleteVertexArraysOES{}
	return obj, doDecodeGlDeleteVertexArraysOES(d, obj)
}
func (*binaryClassGlDeleteVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDeleteVertexArraysOES(d, obj.(*GlDeleteVertexArraysOES))
}
func (*binaryClassGlDeleteVertexArraysOES) Skip(d binary.Decoder) error {
	return doSkipGlDeleteVertexArraysOES(d)
}
func (*binaryClassGlDeleteVertexArraysOES) Schema() *schema.Class {
	return schemaGlDeleteVertexArraysOES
}

var schemaGlDeleteVertexArraysOES = &schema.Class{
	TypeID:  binaryIDGlDeleteVertexArraysOES,
	Package: "gles",
	Name:    "GlDeleteVertexArraysOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᶜᵖ", ID: (*VertexArrayIdᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDepthFunc struct{}

func (*GlDepthFunc) Class() binary.Class {
	return (*binaryClassGlDepthFunc)(nil)
}
func doEncodeGlDepthFunc(e binary.Encoder, o *GlDepthFunc) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Function)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDepthFunc(d binary.Decoder, o *GlDepthFunc) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Function = GLenum(obj)
	}
	return nil
}
func doSkipGlDepthFunc(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDepthFunc) ID() binary.ID      { return binaryIDGlDepthFunc }
func (*binaryClassGlDepthFunc) New() binary.Object { return &GlDepthFunc{} }
func (*binaryClassGlDepthFunc) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDepthFunc(e, obj.(*GlDepthFunc))
}
func (*binaryClassGlDepthFunc) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDepthFunc{}
	return obj, doDecodeGlDepthFunc(d, obj)
}
func (*binaryClassGlDepthFunc) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDepthFunc(d, obj.(*GlDepthFunc))
}
func (*binaryClassGlDepthFunc) Skip(d binary.Decoder) error { return doSkipGlDepthFunc(d) }
func (*binaryClassGlDepthFunc) Schema() *schema.Class       { return schemaGlDepthFunc }

var schemaGlDepthFunc = &schema.Class{
	TypeID:  binaryIDGlDepthFunc,
	Package: "gles",
	Name:    "GlDepthFunc",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Function", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlDepthMask struct{}

func (*GlDepthMask) Class() binary.Class {
	return (*binaryClassGlDepthMask)(nil)
}
func doEncodeGlDepthMask(e binary.Encoder, o *GlDepthMask) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Enabled)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDepthMask(d binary.Decoder, o *GlDepthMask) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Enabled = GLboolean(obj)
	}
	return nil
}
func doSkipGlDepthMask(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDepthMask) ID() binary.ID      { return binaryIDGlDepthMask }
func (*binaryClassGlDepthMask) New() binary.Object { return &GlDepthMask{} }
func (*binaryClassGlDepthMask) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDepthMask(e, obj.(*GlDepthMask))
}
func (*binaryClassGlDepthMask) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDepthMask{}
	return obj, doDecodeGlDepthMask(d, obj)
}
func (*binaryClassGlDepthMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDepthMask(d, obj.(*GlDepthMask))
}
func (*binaryClassGlDepthMask) Skip(d binary.Decoder) error { return doSkipGlDepthMask(d) }
func (*binaryClassGlDepthMask) Schema() *schema.Class       { return schemaGlDepthMask }

var schemaGlDepthMask = &schema.Class{
	TypeID:  binaryIDGlDepthMask,
	Package: "gles",
	Name:    "GlDepthMask",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Enabled", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlDepthRangeArrayfvNV struct{}

func (*GlDepthRangeArrayfvNV) Class() binary.Class {
	return (*binaryClassGlDepthRangeArrayfvNV)(nil)
}
func doEncodeGlDepthRangeArrayfvNV(e binary.Encoder, o *GlDepthRangeArrayfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDepthRangeArrayfvNV(d binary.Decoder, o *GlDepthRangeArrayfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.First = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlDepthRangeArrayfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDepthRangeArrayfvNV) ID() binary.ID      { return binaryIDGlDepthRangeArrayfvNV }
func (*binaryClassGlDepthRangeArrayfvNV) New() binary.Object { return &GlDepthRangeArrayfvNV{} }
func (*binaryClassGlDepthRangeArrayfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDepthRangeArrayfvNV(e, obj.(*GlDepthRangeArrayfvNV))
}
func (*binaryClassGlDepthRangeArrayfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDepthRangeArrayfvNV{}
	return obj, doDecodeGlDepthRangeArrayfvNV(d, obj)
}
func (*binaryClassGlDepthRangeArrayfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDepthRangeArrayfvNV(d, obj.(*GlDepthRangeArrayfvNV))
}
func (*binaryClassGlDepthRangeArrayfvNV) Skip(d binary.Decoder) error {
	return doSkipGlDepthRangeArrayfvNV(d)
}
func (*binaryClassGlDepthRangeArrayfvNV) Schema() *schema.Class { return schemaGlDepthRangeArrayfvNV }

var schemaGlDepthRangeArrayfvNV = &schema.Class{
	TypeID:  binaryIDGlDepthRangeArrayfvNV,
	Package: "gles",
	Name:    "GlDepthRangeArrayfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDepthRangeIndexedfNV struct{}

func (*GlDepthRangeIndexedfNV) Class() binary.Class {
	return (*binaryClassGlDepthRangeIndexedfNV)(nil)
}
func doEncodeGlDepthRangeIndexedfNV(e binary.Encoder, o *GlDepthRangeIndexedfNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.N)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.F)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDepthRangeIndexedfNV(d binary.Decoder, o *GlDepthRangeIndexedfNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.N = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.F = GLfloat(obj)
	}
	return nil
}
func doSkipGlDepthRangeIndexedfNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDepthRangeIndexedfNV) ID() binary.ID      { return binaryIDGlDepthRangeIndexedfNV }
func (*binaryClassGlDepthRangeIndexedfNV) New() binary.Object { return &GlDepthRangeIndexedfNV{} }
func (*binaryClassGlDepthRangeIndexedfNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDepthRangeIndexedfNV(e, obj.(*GlDepthRangeIndexedfNV))
}
func (*binaryClassGlDepthRangeIndexedfNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDepthRangeIndexedfNV{}
	return obj, doDecodeGlDepthRangeIndexedfNV(d, obj)
}
func (*binaryClassGlDepthRangeIndexedfNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDepthRangeIndexedfNV(d, obj.(*GlDepthRangeIndexedfNV))
}
func (*binaryClassGlDepthRangeIndexedfNV) Skip(d binary.Decoder) error {
	return doSkipGlDepthRangeIndexedfNV(d)
}
func (*binaryClassGlDepthRangeIndexedfNV) Schema() *schema.Class { return schemaGlDepthRangeIndexedfNV }

var schemaGlDepthRangeIndexedfNV = &schema.Class{
	TypeID:  binaryIDGlDepthRangeIndexedfNV,
	Package: "gles",
	Name:    "GlDepthRangeIndexedfNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "F", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlDepthRangef struct{}

func (*GlDepthRangef) Class() binary.Class {
	return (*binaryClassGlDepthRangef)(nil)
}
func doEncodeGlDepthRangef(e binary.Encoder, o *GlDepthRangef) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Near)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Far)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDepthRangef(d binary.Decoder, o *GlDepthRangef) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Near = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Far = GLfloat(obj)
	}
	return nil
}
func doSkipGlDepthRangef(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDepthRangef) ID() binary.ID      { return binaryIDGlDepthRangef }
func (*binaryClassGlDepthRangef) New() binary.Object { return &GlDepthRangef{} }
func (*binaryClassGlDepthRangef) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDepthRangef(e, obj.(*GlDepthRangef))
}
func (*binaryClassGlDepthRangef) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDepthRangef{}
	return obj, doDecodeGlDepthRangef(d, obj)
}
func (*binaryClassGlDepthRangef) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDepthRangef(d, obj.(*GlDepthRangef))
}
func (*binaryClassGlDepthRangef) Skip(d binary.Decoder) error { return doSkipGlDepthRangef(d) }
func (*binaryClassGlDepthRangef) Schema() *schema.Class       { return schemaGlDepthRangef }

var schemaGlDepthRangef = &schema.Class{
	TypeID:  binaryIDGlDepthRangef,
	Package: "gles",
	Name:    "GlDepthRangef",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Near", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Far", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlDetachShader struct{}

func (*GlDetachShader) Class() binary.Class {
	return (*binaryClassGlDetachShader)(nil)
}
func doEncodeGlDetachShader(e binary.Encoder, o *GlDetachShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDetachShader(d binary.Decoder, o *GlDetachShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	return nil
}
func doSkipGlDetachShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDetachShader) ID() binary.ID      { return binaryIDGlDetachShader }
func (*binaryClassGlDetachShader) New() binary.Object { return &GlDetachShader{} }
func (*binaryClassGlDetachShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDetachShader(e, obj.(*GlDetachShader))
}
func (*binaryClassGlDetachShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDetachShader{}
	return obj, doDecodeGlDetachShader(d, obj)
}
func (*binaryClassGlDetachShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDetachShader(d, obj.(*GlDetachShader))
}
func (*binaryClassGlDetachShader) Skip(d binary.Decoder) error { return doSkipGlDetachShader(d) }
func (*binaryClassGlDetachShader) Schema() *schema.Class       { return schemaGlDetachShader }

var schemaGlDetachShader = &schema.Class{
	TypeID:  binaryIDGlDetachShader,
	Package: "gles",
	Name:    "GlDetachShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
	},
}

type binaryClassGlDisable struct{}

func (*GlDisable) Class() binary.Class {
	return (*binaryClassGlDisable)(nil)
}
func doEncodeGlDisable(e binary.Encoder, o *GlDisable) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Capability)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisable(d binary.Decoder, o *GlDisable) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Capability = GLenum(obj)
	}
	return nil
}
func doSkipGlDisable(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisable) ID() binary.ID      { return binaryIDGlDisable }
func (*binaryClassGlDisable) New() binary.Object { return &GlDisable{} }
func (*binaryClassGlDisable) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisable(e, obj.(*GlDisable))
}
func (*binaryClassGlDisable) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisable{}
	return obj, doDecodeGlDisable(d, obj)
}
func (*binaryClassGlDisable) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisable(d, obj.(*GlDisable))
}
func (*binaryClassGlDisable) Skip(d binary.Decoder) error { return doSkipGlDisable(d) }
func (*binaryClassGlDisable) Schema() *schema.Class       { return schemaGlDisable }

var schemaGlDisable = &schema.Class{
	TypeID:  binaryIDGlDisable,
	Package: "gles",
	Name:    "GlDisable",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Capability", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlDisableDriverControlQCOM struct{}

func (*GlDisableDriverControlQCOM) Class() binary.Class {
	return (*binaryClassGlDisableDriverControlQCOM)(nil)
}
func doEncodeGlDisableDriverControlQCOM(e binary.Encoder, o *GlDisableDriverControlQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DriverControl)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisableDriverControlQCOM(d binary.Decoder, o *GlDisableDriverControlQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DriverControl = GLuint(obj)
	}
	return nil
}
func doSkipGlDisableDriverControlQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisableDriverControlQCOM) ID() binary.ID {
	return binaryIDGlDisableDriverControlQCOM
}
func (*binaryClassGlDisableDriverControlQCOM) New() binary.Object {
	return &GlDisableDriverControlQCOM{}
}
func (*binaryClassGlDisableDriverControlQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisableDriverControlQCOM(e, obj.(*GlDisableDriverControlQCOM))
}
func (*binaryClassGlDisableDriverControlQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisableDriverControlQCOM{}
	return obj, doDecodeGlDisableDriverControlQCOM(d, obj)
}
func (*binaryClassGlDisableDriverControlQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisableDriverControlQCOM(d, obj.(*GlDisableDriverControlQCOM))
}
func (*binaryClassGlDisableDriverControlQCOM) Skip(d binary.Decoder) error {
	return doSkipGlDisableDriverControlQCOM(d)
}
func (*binaryClassGlDisableDriverControlQCOM) Schema() *schema.Class {
	return schemaGlDisableDriverControlQCOM
}

var schemaGlDisableDriverControlQCOM = &schema.Class{
	TypeID:  binaryIDGlDisableDriverControlQCOM,
	Package: "gles",
	Name:    "GlDisableDriverControlQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DriverControl", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDisableVertexAttribArray struct{}

func (*GlDisableVertexAttribArray) Class() binary.Class {
	return (*binaryClassGlDisableVertexAttribArray)(nil)
}
func doEncodeGlDisableVertexAttribArray(e binary.Encoder, o *GlDisableVertexAttribArray) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisableVertexAttribArray(d binary.Decoder, o *GlDisableVertexAttribArray) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	return nil
}
func doSkipGlDisableVertexAttribArray(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisableVertexAttribArray) ID() binary.ID {
	return binaryIDGlDisableVertexAttribArray
}
func (*binaryClassGlDisableVertexAttribArray) New() binary.Object {
	return &GlDisableVertexAttribArray{}
}
func (*binaryClassGlDisableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisableVertexAttribArray(e, obj.(*GlDisableVertexAttribArray))
}
func (*binaryClassGlDisableVertexAttribArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisableVertexAttribArray{}
	return obj, doDecodeGlDisableVertexAttribArray(d, obj)
}
func (*binaryClassGlDisableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisableVertexAttribArray(d, obj.(*GlDisableVertexAttribArray))
}
func (*binaryClassGlDisableVertexAttribArray) Skip(d binary.Decoder) error {
	return doSkipGlDisableVertexAttribArray(d)
}
func (*binaryClassGlDisableVertexAttribArray) Schema() *schema.Class {
	return schemaGlDisableVertexAttribArray
}

var schemaGlDisableVertexAttribArray = &schema.Class{
	TypeID:  binaryIDGlDisableVertexAttribArray,
	Package: "gles",
	Name:    "GlDisableVertexAttribArray",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
	},
}

type binaryClassGlDisableiEXT struct{}

func (*GlDisableiEXT) Class() binary.Class {
	return (*binaryClassGlDisableiEXT)(nil)
}
func doEncodeGlDisableiEXT(e binary.Encoder, o *GlDisableiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisableiEXT(d binary.Decoder, o *GlDisableiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlDisableiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisableiEXT) ID() binary.ID      { return binaryIDGlDisableiEXT }
func (*binaryClassGlDisableiEXT) New() binary.Object { return &GlDisableiEXT{} }
func (*binaryClassGlDisableiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisableiEXT(e, obj.(*GlDisableiEXT))
}
func (*binaryClassGlDisableiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisableiEXT{}
	return obj, doDecodeGlDisableiEXT(d, obj)
}
func (*binaryClassGlDisableiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisableiEXT(d, obj.(*GlDisableiEXT))
}
func (*binaryClassGlDisableiEXT) Skip(d binary.Decoder) error { return doSkipGlDisableiEXT(d) }
func (*binaryClassGlDisableiEXT) Schema() *schema.Class       { return schemaGlDisableiEXT }

var schemaGlDisableiEXT = &schema.Class{
	TypeID:  binaryIDGlDisableiEXT,
	Package: "gles",
	Name:    "GlDisableiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDisableiNV struct{}

func (*GlDisableiNV) Class() binary.Class {
	return (*binaryClassGlDisableiNV)(nil)
}
func doEncodeGlDisableiNV(e binary.Encoder, o *GlDisableiNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisableiNV(d binary.Decoder, o *GlDisableiNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlDisableiNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisableiNV) ID() binary.ID      { return binaryIDGlDisableiNV }
func (*binaryClassGlDisableiNV) New() binary.Object { return &GlDisableiNV{} }
func (*binaryClassGlDisableiNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisableiNV(e, obj.(*GlDisableiNV))
}
func (*binaryClassGlDisableiNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisableiNV{}
	return obj, doDecodeGlDisableiNV(d, obj)
}
func (*binaryClassGlDisableiNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisableiNV(d, obj.(*GlDisableiNV))
}
func (*binaryClassGlDisableiNV) Skip(d binary.Decoder) error { return doSkipGlDisableiNV(d) }
func (*binaryClassGlDisableiNV) Schema() *schema.Class       { return schemaGlDisableiNV }

var schemaGlDisableiNV = &schema.Class{
	TypeID:  binaryIDGlDisableiNV,
	Package: "gles",
	Name:    "GlDisableiNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDisableiOES struct{}

func (*GlDisableiOES) Class() binary.Class {
	return (*binaryClassGlDisableiOES)(nil)
}
func doEncodeGlDisableiOES(e binary.Encoder, o *GlDisableiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDisableiOES(d binary.Decoder, o *GlDisableiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlDisableiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDisableiOES) ID() binary.ID      { return binaryIDGlDisableiOES }
func (*binaryClassGlDisableiOES) New() binary.Object { return &GlDisableiOES{} }
func (*binaryClassGlDisableiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDisableiOES(e, obj.(*GlDisableiOES))
}
func (*binaryClassGlDisableiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDisableiOES{}
	return obj, doDecodeGlDisableiOES(d, obj)
}
func (*binaryClassGlDisableiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDisableiOES(d, obj.(*GlDisableiOES))
}
func (*binaryClassGlDisableiOES) Skip(d binary.Decoder) error { return doSkipGlDisableiOES(d) }
func (*binaryClassGlDisableiOES) Schema() *schema.Class       { return schemaGlDisableiOES }

var schemaGlDisableiOES = &schema.Class{
	TypeID:  binaryIDGlDisableiOES,
	Package: "gles",
	Name:    "GlDisableiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDiscardFramebufferEXT struct{}

func (*GlDiscardFramebufferEXT) Class() binary.Class {
	return (*binaryClassGlDiscardFramebufferEXT)(nil)
}
func doEncodeGlDiscardFramebufferEXT(e binary.Encoder, o *GlDiscardFramebufferEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumAttachments)); err != nil {
		return err
	}
	if err := e.Value(&o.Attachments); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDiscardFramebufferEXT(d binary.Decoder, o *GlDiscardFramebufferEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumAttachments = GLsizei(obj)
	}
	if err := d.Value(&o.Attachments); err != nil {
		return err
	}
	return nil
}
func doSkipGlDiscardFramebufferEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDiscardFramebufferEXT) ID() binary.ID      { return binaryIDGlDiscardFramebufferEXT }
func (*binaryClassGlDiscardFramebufferEXT) New() binary.Object { return &GlDiscardFramebufferEXT{} }
func (*binaryClassGlDiscardFramebufferEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDiscardFramebufferEXT(e, obj.(*GlDiscardFramebufferEXT))
}
func (*binaryClassGlDiscardFramebufferEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDiscardFramebufferEXT{}
	return obj, doDecodeGlDiscardFramebufferEXT(d, obj)
}
func (*binaryClassGlDiscardFramebufferEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDiscardFramebufferEXT(d, obj.(*GlDiscardFramebufferEXT))
}
func (*binaryClassGlDiscardFramebufferEXT) Skip(d binary.Decoder) error {
	return doSkipGlDiscardFramebufferEXT(d)
}
func (*binaryClassGlDiscardFramebufferEXT) Schema() *schema.Class {
	return schemaGlDiscardFramebufferEXT
}

var schemaGlDiscardFramebufferEXT = &schema.Class{
	TypeID:  binaryIDGlDiscardFramebufferEXT,
	Package: "gles",
	Name:    "GlDiscardFramebufferEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "NumAttachments", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Attachments", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDispatchCompute struct{}

func (*GlDispatchCompute) Class() binary.Class {
	return (*binaryClassGlDispatchCompute)(nil)
}
func doEncodeGlDispatchCompute(e binary.Encoder, o *GlDispatchCompute) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.NumGroupsX)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.NumGroupsY)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.NumGroupsZ)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDispatchCompute(d binary.Decoder, o *GlDispatchCompute) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.NumGroupsX = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.NumGroupsY = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.NumGroupsZ = GLuint(obj)
	}
	return nil
}
func doSkipGlDispatchCompute(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDispatchCompute) ID() binary.ID      { return binaryIDGlDispatchCompute }
func (*binaryClassGlDispatchCompute) New() binary.Object { return &GlDispatchCompute{} }
func (*binaryClassGlDispatchCompute) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDispatchCompute(e, obj.(*GlDispatchCompute))
}
func (*binaryClassGlDispatchCompute) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDispatchCompute{}
	return obj, doDecodeGlDispatchCompute(d, obj)
}
func (*binaryClassGlDispatchCompute) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDispatchCompute(d, obj.(*GlDispatchCompute))
}
func (*binaryClassGlDispatchCompute) Skip(d binary.Decoder) error { return doSkipGlDispatchCompute(d) }
func (*binaryClassGlDispatchCompute) Schema() *schema.Class       { return schemaGlDispatchCompute }

var schemaGlDispatchCompute = &schema.Class{
	TypeID:  binaryIDGlDispatchCompute,
	Package: "gles",
	Name:    "GlDispatchCompute",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumGroupsX", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumGroupsY", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumGroupsZ", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDispatchComputeIndirect struct{}

func (*GlDispatchComputeIndirect) Class() binary.Class {
	return (*binaryClassGlDispatchComputeIndirect)(nil)
}
func doEncodeGlDispatchComputeIndirect(e binary.Encoder, o *GlDispatchComputeIndirect) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Indirect)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDispatchComputeIndirect(d binary.Decoder, o *GlDispatchComputeIndirect) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Indirect = GLintptr(obj)
	}
	return nil
}
func doSkipGlDispatchComputeIndirect(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDispatchComputeIndirect) ID() binary.ID      { return binaryIDGlDispatchComputeIndirect }
func (*binaryClassGlDispatchComputeIndirect) New() binary.Object { return &GlDispatchComputeIndirect{} }
func (*binaryClassGlDispatchComputeIndirect) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDispatchComputeIndirect(e, obj.(*GlDispatchComputeIndirect))
}
func (*binaryClassGlDispatchComputeIndirect) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDispatchComputeIndirect{}
	return obj, doDecodeGlDispatchComputeIndirect(d, obj)
}
func (*binaryClassGlDispatchComputeIndirect) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDispatchComputeIndirect(d, obj.(*GlDispatchComputeIndirect))
}
func (*binaryClassGlDispatchComputeIndirect) Skip(d binary.Decoder) error {
	return doSkipGlDispatchComputeIndirect(d)
}
func (*binaryClassGlDispatchComputeIndirect) Schema() *schema.Class {
	return schemaGlDispatchComputeIndirect
}

var schemaGlDispatchComputeIndirect = &schema.Class{
	TypeID:  binaryIDGlDispatchComputeIndirect,
	Package: "gles",
	Name:    "GlDispatchComputeIndirect",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Indirect", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
	},
}

type binaryClassGlDrawArrays struct{}

func (*GlDrawArrays) Class() binary.Class {
	return (*binaryClassGlDrawArrays)(nil)
}
func doEncodeGlDrawArrays(e binary.Encoder, o *GlDrawArrays) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DrawMode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.FirstIndex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.IndexCount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArrays(d binary.Decoder, o *GlDrawArrays) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DrawMode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.FirstIndex = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.IndexCount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawArrays(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArrays) ID() binary.ID      { return binaryIDGlDrawArrays }
func (*binaryClassGlDrawArrays) New() binary.Object { return &GlDrawArrays{} }
func (*binaryClassGlDrawArrays) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArrays(e, obj.(*GlDrawArrays))
}
func (*binaryClassGlDrawArrays) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArrays{}
	return obj, doDecodeGlDrawArrays(d, obj)
}
func (*binaryClassGlDrawArrays) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArrays(d, obj.(*GlDrawArrays))
}
func (*binaryClassGlDrawArrays) Skip(d binary.Decoder) error { return doSkipGlDrawArrays(d) }
func (*binaryClassGlDrawArrays) Schema() *schema.Class       { return schemaGlDrawArrays }

var schemaGlDrawArrays = &schema.Class{
	TypeID:  binaryIDGlDrawArrays,
	Package: "gles",
	Name:    "GlDrawArrays",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DrawMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FirstIndex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "IndexCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawArraysIndirect struct{}

func (*GlDrawArraysIndirect) Class() binary.Class {
	return (*binaryClassGlDrawArraysIndirect)(nil)
}
func doEncodeGlDrawArraysIndirect(e binary.Encoder, o *GlDrawArraysIndirect) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.Indirect); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysIndirect(d binary.Decoder, o *GlDrawArraysIndirect) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.Indirect); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawArraysIndirect(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysIndirect) ID() binary.ID      { return binaryIDGlDrawArraysIndirect }
func (*binaryClassGlDrawArraysIndirect) New() binary.Object { return &GlDrawArraysIndirect{} }
func (*binaryClassGlDrawArraysIndirect) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysIndirect(e, obj.(*GlDrawArraysIndirect))
}
func (*binaryClassGlDrawArraysIndirect) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysIndirect{}
	return obj, doDecodeGlDrawArraysIndirect(d, obj)
}
func (*binaryClassGlDrawArraysIndirect) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysIndirect(d, obj.(*GlDrawArraysIndirect))
}
func (*binaryClassGlDrawArraysIndirect) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysIndirect(d)
}
func (*binaryClassGlDrawArraysIndirect) Schema() *schema.Class { return schemaGlDrawArraysIndirect }

var schemaGlDrawArraysIndirect = &schema.Class{
	TypeID:  binaryIDGlDrawArraysIndirect,
	Package: "gles",
	Name:    "GlDrawArraysIndirect",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indirect", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawArraysInstanced struct{}

func (*GlDrawArraysInstanced) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstanced)(nil)
}
func doEncodeGlDrawArraysInstanced(e binary.Encoder, o *GlDrawArraysInstanced) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysInstanced(d binary.Decoder, o *GlDrawArraysInstanced) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.First = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawArraysInstanced(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysInstanced) ID() binary.ID      { return binaryIDGlDrawArraysInstanced }
func (*binaryClassGlDrawArraysInstanced) New() binary.Object { return &GlDrawArraysInstanced{} }
func (*binaryClassGlDrawArraysInstanced) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysInstanced(e, obj.(*GlDrawArraysInstanced))
}
func (*binaryClassGlDrawArraysInstanced) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysInstanced{}
	return obj, doDecodeGlDrawArraysInstanced(d, obj)
}
func (*binaryClassGlDrawArraysInstanced) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysInstanced(d, obj.(*GlDrawArraysInstanced))
}
func (*binaryClassGlDrawArraysInstanced) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysInstanced(d)
}
func (*binaryClassGlDrawArraysInstanced) Schema() *schema.Class { return schemaGlDrawArraysInstanced }

var schemaGlDrawArraysInstanced = &schema.Class{
	TypeID:  binaryIDGlDrawArraysInstanced,
	Package: "gles",
	Name:    "GlDrawArraysInstanced",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawArraysInstancedANGLE struct{}

func (*GlDrawArraysInstancedANGLE) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedANGLE)(nil)
}
func doEncodeGlDrawArraysInstancedANGLE(e binary.Encoder, o *GlDrawArraysInstancedANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysInstancedANGLE(d binary.Decoder, o *GlDrawArraysInstancedANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.First = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawArraysInstancedANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysInstancedANGLE) ID() binary.ID {
	return binaryIDGlDrawArraysInstancedANGLE
}
func (*binaryClassGlDrawArraysInstancedANGLE) New() binary.Object {
	return &GlDrawArraysInstancedANGLE{}
}
func (*binaryClassGlDrawArraysInstancedANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysInstancedANGLE(e, obj.(*GlDrawArraysInstancedANGLE))
}
func (*binaryClassGlDrawArraysInstancedANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysInstancedANGLE{}
	return obj, doDecodeGlDrawArraysInstancedANGLE(d, obj)
}
func (*binaryClassGlDrawArraysInstancedANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysInstancedANGLE(d, obj.(*GlDrawArraysInstancedANGLE))
}
func (*binaryClassGlDrawArraysInstancedANGLE) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysInstancedANGLE(d)
}
func (*binaryClassGlDrawArraysInstancedANGLE) Schema() *schema.Class {
	return schemaGlDrawArraysInstancedANGLE
}

var schemaGlDrawArraysInstancedANGLE = &schema.Class{
	TypeID:  binaryIDGlDrawArraysInstancedANGLE,
	Package: "gles",
	Name:    "GlDrawArraysInstancedANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawArraysInstancedBaseInstanceEXT struct{}

func (*GlDrawArraysInstancedBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedBaseInstanceEXT)(nil)
}
func doEncodeGlDrawArraysInstancedBaseInstanceEXT(e binary.Encoder, o *GlDrawArraysInstancedBaseInstanceEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Baseinstance)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawArraysInstancedBaseInstanceEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.First = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Baseinstance = GLuint(obj)
	}
	return nil
}
func doSkipGlDrawArraysInstancedBaseInstanceEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) ID() binary.ID {
	return binaryIDGlDrawArraysInstancedBaseInstanceEXT
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) New() binary.Object {
	return &GlDrawArraysInstancedBaseInstanceEXT{}
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysInstancedBaseInstanceEXT(e, obj.(*GlDrawArraysInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysInstancedBaseInstanceEXT{}
	return obj, doDecodeGlDrawArraysInstancedBaseInstanceEXT(d, obj)
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysInstancedBaseInstanceEXT(d, obj.(*GlDrawArraysInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysInstancedBaseInstanceEXT(d)
}
func (*binaryClassGlDrawArraysInstancedBaseInstanceEXT) Schema() *schema.Class {
	return schemaGlDrawArraysInstancedBaseInstanceEXT
}

var schemaGlDrawArraysInstancedBaseInstanceEXT = &schema.Class{
	TypeID:  binaryIDGlDrawArraysInstancedBaseInstanceEXT,
	Package: "gles",
	Name:    "GlDrawArraysInstancedBaseInstanceEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Baseinstance", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDrawArraysInstancedEXT struct{}

func (*GlDrawArraysInstancedEXT) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedEXT)(nil)
}
func doEncodeGlDrawArraysInstancedEXT(e binary.Encoder, o *GlDrawArraysInstancedEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Start)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysInstancedEXT(d binary.Decoder, o *GlDrawArraysInstancedEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Start = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawArraysInstancedEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysInstancedEXT) ID() binary.ID      { return binaryIDGlDrawArraysInstancedEXT }
func (*binaryClassGlDrawArraysInstancedEXT) New() binary.Object { return &GlDrawArraysInstancedEXT{} }
func (*binaryClassGlDrawArraysInstancedEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysInstancedEXT(e, obj.(*GlDrawArraysInstancedEXT))
}
func (*binaryClassGlDrawArraysInstancedEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysInstancedEXT{}
	return obj, doDecodeGlDrawArraysInstancedEXT(d, obj)
}
func (*binaryClassGlDrawArraysInstancedEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysInstancedEXT(d, obj.(*GlDrawArraysInstancedEXT))
}
func (*binaryClassGlDrawArraysInstancedEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysInstancedEXT(d)
}
func (*binaryClassGlDrawArraysInstancedEXT) Schema() *schema.Class {
	return schemaGlDrawArraysInstancedEXT
}

var schemaGlDrawArraysInstancedEXT = &schema.Class{
	TypeID:  binaryIDGlDrawArraysInstancedEXT,
	Package: "gles",
	Name:    "GlDrawArraysInstancedEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawArraysInstancedNV struct{}

func (*GlDrawArraysInstancedNV) Class() binary.Class {
	return (*binaryClassGlDrawArraysInstancedNV)(nil)
}
func doEncodeGlDrawArraysInstancedNV(e binary.Encoder, o *GlDrawArraysInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawArraysInstancedNV(d binary.Decoder, o *GlDrawArraysInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.First = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawArraysInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawArraysInstancedNV) ID() binary.ID      { return binaryIDGlDrawArraysInstancedNV }
func (*binaryClassGlDrawArraysInstancedNV) New() binary.Object { return &GlDrawArraysInstancedNV{} }
func (*binaryClassGlDrawArraysInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawArraysInstancedNV(e, obj.(*GlDrawArraysInstancedNV))
}
func (*binaryClassGlDrawArraysInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawArraysInstancedNV{}
	return obj, doDecodeGlDrawArraysInstancedNV(d, obj)
}
func (*binaryClassGlDrawArraysInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawArraysInstancedNV(d, obj.(*GlDrawArraysInstancedNV))
}
func (*binaryClassGlDrawArraysInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlDrawArraysInstancedNV(d)
}
func (*binaryClassGlDrawArraysInstancedNV) Schema() *schema.Class {
	return schemaGlDrawArraysInstancedNV
}

var schemaGlDrawArraysInstancedNV = &schema.Class{
	TypeID:  binaryIDGlDrawArraysInstancedNV,
	Package: "gles",
	Name:    "GlDrawArraysInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawBuffers struct{}

func (*GlDrawBuffers) Class() binary.Class {
	return (*binaryClassGlDrawBuffers)(nil)
}
func doEncodeGlDrawBuffers(e binary.Encoder, o *GlDrawBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawBuffers(d binary.Decoder, o *GlDrawBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawBuffers) ID() binary.ID      { return binaryIDGlDrawBuffers }
func (*binaryClassGlDrawBuffers) New() binary.Object { return &GlDrawBuffers{} }
func (*binaryClassGlDrawBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawBuffers(e, obj.(*GlDrawBuffers))
}
func (*binaryClassGlDrawBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawBuffers{}
	return obj, doDecodeGlDrawBuffers(d, obj)
}
func (*binaryClassGlDrawBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawBuffers(d, obj.(*GlDrawBuffers))
}
func (*binaryClassGlDrawBuffers) Skip(d binary.Decoder) error { return doSkipGlDrawBuffers(d) }
func (*binaryClassGlDrawBuffers) Schema() *schema.Class       { return schemaGlDrawBuffers }

var schemaGlDrawBuffers = &schema.Class{
	TypeID:  binaryIDGlDrawBuffers,
	Package: "gles",
	Name:    "GlDrawBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Bufs", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawBuffersEXT struct{}

func (*GlDrawBuffersEXT) Class() binary.Class {
	return (*binaryClassGlDrawBuffersEXT)(nil)
}
func doEncodeGlDrawBuffersEXT(e binary.Encoder, o *GlDrawBuffersEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawBuffersEXT(d binary.Decoder, o *GlDrawBuffersEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawBuffersEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawBuffersEXT) ID() binary.ID      { return binaryIDGlDrawBuffersEXT }
func (*binaryClassGlDrawBuffersEXT) New() binary.Object { return &GlDrawBuffersEXT{} }
func (*binaryClassGlDrawBuffersEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawBuffersEXT(e, obj.(*GlDrawBuffersEXT))
}
func (*binaryClassGlDrawBuffersEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawBuffersEXT{}
	return obj, doDecodeGlDrawBuffersEXT(d, obj)
}
func (*binaryClassGlDrawBuffersEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawBuffersEXT(d, obj.(*GlDrawBuffersEXT))
}
func (*binaryClassGlDrawBuffersEXT) Skip(d binary.Decoder) error { return doSkipGlDrawBuffersEXT(d) }
func (*binaryClassGlDrawBuffersEXT) Schema() *schema.Class       { return schemaGlDrawBuffersEXT }

var schemaGlDrawBuffersEXT = &schema.Class{
	TypeID:  binaryIDGlDrawBuffersEXT,
	Package: "gles",
	Name:    "GlDrawBuffersEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Bufs", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawBuffersIndexedEXT struct{}

func (*GlDrawBuffersIndexedEXT) Class() binary.Class {
	return (*binaryClassGlDrawBuffersIndexedEXT)(nil)
}
func doEncodeGlDrawBuffersIndexedEXT(e binary.Encoder, o *GlDrawBuffersIndexedEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Location); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawBuffersIndexedEXT(d binary.Decoder, o *GlDrawBuffersIndexedEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLint(obj)
	}
	if err := d.Value(&o.Location); err != nil {
		return err
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawBuffersIndexedEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawBuffersIndexedEXT) ID() binary.ID      { return binaryIDGlDrawBuffersIndexedEXT }
func (*binaryClassGlDrawBuffersIndexedEXT) New() binary.Object { return &GlDrawBuffersIndexedEXT{} }
func (*binaryClassGlDrawBuffersIndexedEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawBuffersIndexedEXT(e, obj.(*GlDrawBuffersIndexedEXT))
}
func (*binaryClassGlDrawBuffersIndexedEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawBuffersIndexedEXT{}
	return obj, doDecodeGlDrawBuffersIndexedEXT(d, obj)
}
func (*binaryClassGlDrawBuffersIndexedEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawBuffersIndexedEXT(d, obj.(*GlDrawBuffersIndexedEXT))
}
func (*binaryClassGlDrawBuffersIndexedEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawBuffersIndexedEXT(d)
}
func (*binaryClassGlDrawBuffersIndexedEXT) Schema() *schema.Class {
	return schemaGlDrawBuffersIndexedEXT
}

var schemaGlDrawBuffersIndexedEXT = &schema.Class{
	TypeID:  binaryIDGlDrawBuffersIndexedEXT,
	Package: "gles",
	Name:    "GlDrawBuffersIndexedEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Location", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
		{Declared: "Indices", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawBuffersNV struct{}

func (*GlDrawBuffersNV) Class() binary.Class {
	return (*binaryClassGlDrawBuffersNV)(nil)
}
func doEncodeGlDrawBuffersNV(e binary.Encoder, o *GlDrawBuffersNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawBuffersNV(d binary.Decoder, o *GlDrawBuffersNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Bufs); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawBuffersNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawBuffersNV) ID() binary.ID      { return binaryIDGlDrawBuffersNV }
func (*binaryClassGlDrawBuffersNV) New() binary.Object { return &GlDrawBuffersNV{} }
func (*binaryClassGlDrawBuffersNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawBuffersNV(e, obj.(*GlDrawBuffersNV))
}
func (*binaryClassGlDrawBuffersNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawBuffersNV{}
	return obj, doDecodeGlDrawBuffersNV(d, obj)
}
func (*binaryClassGlDrawBuffersNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawBuffersNV(d, obj.(*GlDrawBuffersNV))
}
func (*binaryClassGlDrawBuffersNV) Skip(d binary.Decoder) error { return doSkipGlDrawBuffersNV(d) }
func (*binaryClassGlDrawBuffersNV) Schema() *schema.Class       { return schemaGlDrawBuffersNV }

var schemaGlDrawBuffersNV = &schema.Class{
	TypeID:  binaryIDGlDrawBuffersNV,
	Package: "gles",
	Name:    "GlDrawBuffersNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Bufs", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassIndicesPointer struct{}

func (*IndicesPointer) Class() binary.Class {
	return (*binaryClassIndicesPointer)(nil)
}
func doEncodeIndicesPointer(e binary.Encoder, o *IndicesPointer) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeIndicesPointer(d binary.Decoder, o *IndicesPointer) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipIndicesPointer(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIndicesPointer) ID() binary.ID      { return binaryIDIndicesPointer }
func (*binaryClassIndicesPointer) New() binary.Object { return &IndicesPointer{} }
func (*binaryClassIndicesPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIndicesPointer(e, obj.(*IndicesPointer))
}
func (*binaryClassIndicesPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &IndicesPointer{}
	return obj, doDecodeIndicesPointer(d, obj)
}
func (*binaryClassIndicesPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIndicesPointer(d, obj.(*IndicesPointer))
}
func (*binaryClassIndicesPointer) Skip(d binary.Decoder) error { return doSkipIndicesPointer(d) }
func (*binaryClassIndicesPointer) Schema() *schema.Class       { return schemaIndicesPointer }

var schemaIndicesPointer = &schema.Class{
	TypeID:  binaryIDIndicesPointer,
	Package: "gles",
	Name:    "IndicesPointer",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawElements struct{}

func (*GlDrawElements) Class() binary.Class {
	return (*binaryClassGlDrawElements)(nil)
}
func doEncodeGlDrawElements(e binary.Encoder, o *GlDrawElements) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DrawMode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ElementCount)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.IndicesType)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElements(d binary.Decoder, o *GlDrawElements) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DrawMode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ElementCount = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.IndicesType = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawElements(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*IndicesPointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElements) ID() binary.ID      { return binaryIDGlDrawElements }
func (*binaryClassGlDrawElements) New() binary.Object { return &GlDrawElements{} }
func (*binaryClassGlDrawElements) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElements(e, obj.(*GlDrawElements))
}
func (*binaryClassGlDrawElements) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElements{}
	return obj, doDecodeGlDrawElements(d, obj)
}
func (*binaryClassGlDrawElements) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElements(d, obj.(*GlDrawElements))
}
func (*binaryClassGlDrawElements) Skip(d binary.Decoder) error { return doSkipGlDrawElements(d) }
func (*binaryClassGlDrawElements) Schema() *schema.Class       { return schemaGlDrawElements }

var schemaGlDrawElements = &schema.Class{
	TypeID:  binaryIDGlDrawElements,
	Package: "gles",
	Name:    "GlDrawElements",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DrawMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ElementCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "IndicesType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "IndicesPointer", ID: (*IndicesPointer)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawElementsBaseVertexEXT struct{}

func (*GlDrawElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsBaseVertexEXT)(nil)
}
func doEncodeGlDrawElementsBaseVertexEXT(e binary.Encoder, o *GlDrawElementsBaseVertexEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsBaseVertexEXT(d binary.Decoder, o *GlDrawElementsBaseVertexEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawElementsBaseVertexEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsBaseVertexEXT) ID() binary.ID {
	return binaryIDGlDrawElementsBaseVertexEXT
}
func (*binaryClassGlDrawElementsBaseVertexEXT) New() binary.Object {
	return &GlDrawElementsBaseVertexEXT{}
}
func (*binaryClassGlDrawElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsBaseVertexEXT(e, obj.(*GlDrawElementsBaseVertexEXT))
}
func (*binaryClassGlDrawElementsBaseVertexEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsBaseVertexEXT{}
	return obj, doDecodeGlDrawElementsBaseVertexEXT(d, obj)
}
func (*binaryClassGlDrawElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsBaseVertexEXT(d, obj.(*GlDrawElementsBaseVertexEXT))
}
func (*binaryClassGlDrawElementsBaseVertexEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsBaseVertexEXT(d)
}
func (*binaryClassGlDrawElementsBaseVertexEXT) Schema() *schema.Class {
	return schemaGlDrawElementsBaseVertexEXT
}

var schemaGlDrawElementsBaseVertexEXT = &schema.Class{
	TypeID:  binaryIDGlDrawElementsBaseVertexEXT,
	Package: "gles",
	Name:    "GlDrawElementsBaseVertexEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsBaseVertexOES struct{}

func (*GlDrawElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawElementsBaseVertexOES)(nil)
}
func doEncodeGlDrawElementsBaseVertexOES(e binary.Encoder, o *GlDrawElementsBaseVertexOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsBaseVertexOES(d binary.Decoder, o *GlDrawElementsBaseVertexOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawElementsBaseVertexOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsBaseVertexOES) ID() binary.ID {
	return binaryIDGlDrawElementsBaseVertexOES
}
func (*binaryClassGlDrawElementsBaseVertexOES) New() binary.Object {
	return &GlDrawElementsBaseVertexOES{}
}
func (*binaryClassGlDrawElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsBaseVertexOES(e, obj.(*GlDrawElementsBaseVertexOES))
}
func (*binaryClassGlDrawElementsBaseVertexOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsBaseVertexOES{}
	return obj, doDecodeGlDrawElementsBaseVertexOES(d, obj)
}
func (*binaryClassGlDrawElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsBaseVertexOES(d, obj.(*GlDrawElementsBaseVertexOES))
}
func (*binaryClassGlDrawElementsBaseVertexOES) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsBaseVertexOES(d)
}
func (*binaryClassGlDrawElementsBaseVertexOES) Schema() *schema.Class {
	return schemaGlDrawElementsBaseVertexOES
}

var schemaGlDrawElementsBaseVertexOES = &schema.Class{
	TypeID:  binaryIDGlDrawElementsBaseVertexOES,
	Package: "gles",
	Name:    "GlDrawElementsBaseVertexOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsIndirect struct{}

func (*GlDrawElementsIndirect) Class() binary.Class {
	return (*binaryClassGlDrawElementsIndirect)(nil)
}
func doEncodeGlDrawElementsIndirect(e binary.Encoder, o *GlDrawElementsIndirect) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indirect); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsIndirect(d binary.Decoder, o *GlDrawElementsIndirect) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indirect); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawElementsIndirect(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsIndirect) ID() binary.ID      { return binaryIDGlDrawElementsIndirect }
func (*binaryClassGlDrawElementsIndirect) New() binary.Object { return &GlDrawElementsIndirect{} }
func (*binaryClassGlDrawElementsIndirect) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsIndirect(e, obj.(*GlDrawElementsIndirect))
}
func (*binaryClassGlDrawElementsIndirect) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsIndirect{}
	return obj, doDecodeGlDrawElementsIndirect(d, obj)
}
func (*binaryClassGlDrawElementsIndirect) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsIndirect(d, obj.(*GlDrawElementsIndirect))
}
func (*binaryClassGlDrawElementsIndirect) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsIndirect(d)
}
func (*binaryClassGlDrawElementsIndirect) Schema() *schema.Class { return schemaGlDrawElementsIndirect }

var schemaGlDrawElementsIndirect = &schema.Class{
	TypeID:  binaryIDGlDrawElementsIndirect,
	Package: "gles",
	Name:    "GlDrawElementsIndirect",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indirect", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawElementsInstanced struct{}

func (*GlDrawElementsInstanced) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstanced)(nil)
}
func doEncodeGlDrawElementsInstanced(e binary.Encoder, o *GlDrawElementsInstanced) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstanced(d binary.Decoder, o *GlDrawElementsInstanced) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstanced(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstanced) ID() binary.ID      { return binaryIDGlDrawElementsInstanced }
func (*binaryClassGlDrawElementsInstanced) New() binary.Object { return &GlDrawElementsInstanced{} }
func (*binaryClassGlDrawElementsInstanced) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstanced(e, obj.(*GlDrawElementsInstanced))
}
func (*binaryClassGlDrawElementsInstanced) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstanced{}
	return obj, doDecodeGlDrawElementsInstanced(d, obj)
}
func (*binaryClassGlDrawElementsInstanced) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstanced(d, obj.(*GlDrawElementsInstanced))
}
func (*binaryClassGlDrawElementsInstanced) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstanced(d)
}
func (*binaryClassGlDrawElementsInstanced) Schema() *schema.Class {
	return schemaGlDrawElementsInstanced
}

var schemaGlDrawElementsInstanced = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstanced,
	Package: "gles",
	Name:    "GlDrawElementsInstanced",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsInstancedANGLE struct{}

func (*GlDrawElementsInstancedANGLE) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedANGLE)(nil)
}
func doEncodeGlDrawElementsInstancedANGLE(e binary.Encoder, o *GlDrawElementsInstancedANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedANGLE(d binary.Decoder, o *GlDrawElementsInstancedANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedANGLE) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedANGLE
}
func (*binaryClassGlDrawElementsInstancedANGLE) New() binary.Object {
	return &GlDrawElementsInstancedANGLE{}
}
func (*binaryClassGlDrawElementsInstancedANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedANGLE(e, obj.(*GlDrawElementsInstancedANGLE))
}
func (*binaryClassGlDrawElementsInstancedANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedANGLE{}
	return obj, doDecodeGlDrawElementsInstancedANGLE(d, obj)
}
func (*binaryClassGlDrawElementsInstancedANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedANGLE(d, obj.(*GlDrawElementsInstancedANGLE))
}
func (*binaryClassGlDrawElementsInstancedANGLE) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedANGLE(d)
}
func (*binaryClassGlDrawElementsInstancedANGLE) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedANGLE
}

var schemaGlDrawElementsInstancedANGLE = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedANGLE,
	Package: "gles",
	Name:    "GlDrawElementsInstancedANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsInstancedBaseInstanceEXT struct{}

func (*GlDrawElementsInstancedBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseInstanceEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseInstanceEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseInstanceEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Baseinstance)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseInstanceEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Baseinstance = GLuint(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedBaseInstanceEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedBaseInstanceEXT
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseInstanceEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedBaseInstanceEXT(e, obj.(*GlDrawElementsInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedBaseInstanceEXT{}
	return obj, doDecodeGlDrawElementsInstancedBaseInstanceEXT(d, obj)
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedBaseInstanceEXT(d, obj.(*GlDrawElementsInstancedBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedBaseInstanceEXT(d)
}
func (*binaryClassGlDrawElementsInstancedBaseInstanceEXT) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedBaseInstanceEXT
}

var schemaGlDrawElementsInstancedBaseInstanceEXT = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedBaseInstanceEXT,
	Package: "gles",
	Name:    "GlDrawElementsInstancedBaseInstanceEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Baseinstance", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT struct{}

func (*GlDrawElementsInstancedBaseVertexBaseInstanceEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Baseinstance)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexBaseInstanceEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Baseinstance = GLuint(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedBaseVertexBaseInstanceEXT
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexBaseInstanceEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(e, obj.(*GlDrawElementsInstancedBaseVertexBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedBaseVertexBaseInstanceEXT{}
	return obj, doDecodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d, obj)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d, obj.(*GlDrawElementsInstancedBaseVertexBaseInstanceEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedBaseVertexBaseInstanceEXT(d)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexBaseInstanceEXT) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedBaseVertexBaseInstanceEXT
}

var schemaGlDrawElementsInstancedBaseVertexBaseInstanceEXT = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedBaseVertexBaseInstanceEXT,
	Package: "gles",
	Name:    "GlDrawElementsInstancedBaseVertexBaseInstanceEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Baseinstance", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlDrawElementsInstancedBaseVertexEXT struct{}

func (*GlDrawElementsInstancedBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexEXT)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexEXT(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedBaseVertexEXT(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedBaseVertexEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedBaseVertexEXT
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexEXT{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedBaseVertexEXT(e, obj.(*GlDrawElementsInstancedBaseVertexEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedBaseVertexEXT{}
	return obj, doDecodeGlDrawElementsInstancedBaseVertexEXT(d, obj)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedBaseVertexEXT(d, obj.(*GlDrawElementsInstancedBaseVertexEXT))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedBaseVertexEXT(d)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexEXT) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedBaseVertexEXT
}

var schemaGlDrawElementsInstancedBaseVertexEXT = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedBaseVertexEXT,
	Package: "gles",
	Name:    "GlDrawElementsInstancedBaseVertexEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsInstancedBaseVertexOES struct{}

func (*GlDrawElementsInstancedBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedBaseVertexOES)(nil)
}
func doEncodeGlDrawElementsInstancedBaseVertexOES(e binary.Encoder, o *GlDrawElementsInstancedBaseVertexOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Instancecount)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedBaseVertexOES(d binary.Decoder, o *GlDrawElementsInstancedBaseVertexOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Instancecount = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedBaseVertexOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedBaseVertexOES
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) New() binary.Object {
	return &GlDrawElementsInstancedBaseVertexOES{}
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedBaseVertexOES(e, obj.(*GlDrawElementsInstancedBaseVertexOES))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedBaseVertexOES{}
	return obj, doDecodeGlDrawElementsInstancedBaseVertexOES(d, obj)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedBaseVertexOES(d, obj.(*GlDrawElementsInstancedBaseVertexOES))
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedBaseVertexOES(d)
}
func (*binaryClassGlDrawElementsInstancedBaseVertexOES) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedBaseVertexOES
}

var schemaGlDrawElementsInstancedBaseVertexOES = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedBaseVertexOES,
	Package: "gles",
	Name:    "GlDrawElementsInstancedBaseVertexOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Instancecount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsInstancedEXT struct{}

func (*GlDrawElementsInstancedEXT) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedEXT)(nil)
}
func doEncodeGlDrawElementsInstancedEXT(e binary.Encoder, o *GlDrawElementsInstancedEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedEXT(d binary.Decoder, o *GlDrawElementsInstancedEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedEXT) ID() binary.ID {
	return binaryIDGlDrawElementsInstancedEXT
}
func (*binaryClassGlDrawElementsInstancedEXT) New() binary.Object {
	return &GlDrawElementsInstancedEXT{}
}
func (*binaryClassGlDrawElementsInstancedEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedEXT(e, obj.(*GlDrawElementsInstancedEXT))
}
func (*binaryClassGlDrawElementsInstancedEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedEXT{}
	return obj, doDecodeGlDrawElementsInstancedEXT(d, obj)
}
func (*binaryClassGlDrawElementsInstancedEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedEXT(d, obj.(*GlDrawElementsInstancedEXT))
}
func (*binaryClassGlDrawElementsInstancedEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedEXT(d)
}
func (*binaryClassGlDrawElementsInstancedEXT) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedEXT
}

var schemaGlDrawElementsInstancedEXT = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedEXT,
	Package: "gles",
	Name:    "GlDrawElementsInstancedEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawElementsInstancedNV struct{}

func (*GlDrawElementsInstancedNV) Class() binary.Class {
	return (*binaryClassGlDrawElementsInstancedNV)(nil)
}
func doEncodeGlDrawElementsInstancedNV(e binary.Encoder, o *GlDrawElementsInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawElementsInstancedNV(d binary.Decoder, o *GlDrawElementsInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlDrawElementsInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawElementsInstancedNV) ID() binary.ID      { return binaryIDGlDrawElementsInstancedNV }
func (*binaryClassGlDrawElementsInstancedNV) New() binary.Object { return &GlDrawElementsInstancedNV{} }
func (*binaryClassGlDrawElementsInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawElementsInstancedNV(e, obj.(*GlDrawElementsInstancedNV))
}
func (*binaryClassGlDrawElementsInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawElementsInstancedNV{}
	return obj, doDecodeGlDrawElementsInstancedNV(d, obj)
}
func (*binaryClassGlDrawElementsInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawElementsInstancedNV(d, obj.(*GlDrawElementsInstancedNV))
}
func (*binaryClassGlDrawElementsInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlDrawElementsInstancedNV(d)
}
func (*binaryClassGlDrawElementsInstancedNV) Schema() *schema.Class {
	return schemaGlDrawElementsInstancedNV
}

var schemaGlDrawElementsInstancedNV = &schema.Class{
	TypeID:  binaryIDGlDrawElementsInstancedNV,
	Package: "gles",
	Name:    "GlDrawElementsInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlDrawRangeElements struct{}

func (*GlDrawRangeElements) Class() binary.Class {
	return (*binaryClassGlDrawRangeElements)(nil)
}
func doEncodeGlDrawRangeElements(e binary.Encoder, o *GlDrawRangeElements) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Start)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.End)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawRangeElements(d binary.Decoder, o *GlDrawRangeElements) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Start = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.End = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	return nil
}
func doSkipGlDrawRangeElements(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawRangeElements) ID() binary.ID      { return binaryIDGlDrawRangeElements }
func (*binaryClassGlDrawRangeElements) New() binary.Object { return &GlDrawRangeElements{} }
func (*binaryClassGlDrawRangeElements) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawRangeElements(e, obj.(*GlDrawRangeElements))
}
func (*binaryClassGlDrawRangeElements) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawRangeElements{}
	return obj, doDecodeGlDrawRangeElements(d, obj)
}
func (*binaryClassGlDrawRangeElements) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawRangeElements(d, obj.(*GlDrawRangeElements))
}
func (*binaryClassGlDrawRangeElements) Skip(d binary.Decoder) error {
	return doSkipGlDrawRangeElements(d)
}
func (*binaryClassGlDrawRangeElements) Schema() *schema.Class { return schemaGlDrawRangeElements }

var schemaGlDrawRangeElements = &schema.Class{
	TypeID:  binaryIDGlDrawRangeElements,
	Package: "gles",
	Name:    "GlDrawRangeElements",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "End", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlDrawRangeElementsBaseVertexEXT struct{}

func (*GlDrawRangeElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlDrawRangeElementsBaseVertexEXT)(nil)
}
func doEncodeGlDrawRangeElementsBaseVertexEXT(e binary.Encoder, o *GlDrawRangeElementsBaseVertexEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Start)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.End)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawRangeElementsBaseVertexEXT(d binary.Decoder, o *GlDrawRangeElementsBaseVertexEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Start = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.End = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawRangeElementsBaseVertexEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) ID() binary.ID {
	return binaryIDGlDrawRangeElementsBaseVertexEXT
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) New() binary.Object {
	return &GlDrawRangeElementsBaseVertexEXT{}
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawRangeElementsBaseVertexEXT(e, obj.(*GlDrawRangeElementsBaseVertexEXT))
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawRangeElementsBaseVertexEXT{}
	return obj, doDecodeGlDrawRangeElementsBaseVertexEXT(d, obj)
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawRangeElementsBaseVertexEXT(d, obj.(*GlDrawRangeElementsBaseVertexEXT))
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) Skip(d binary.Decoder) error {
	return doSkipGlDrawRangeElementsBaseVertexEXT(d)
}
func (*binaryClassGlDrawRangeElementsBaseVertexEXT) Schema() *schema.Class {
	return schemaGlDrawRangeElementsBaseVertexEXT
}

var schemaGlDrawRangeElementsBaseVertexEXT = &schema.Class{
	TypeID:  binaryIDGlDrawRangeElementsBaseVertexEXT,
	Package: "gles",
	Name:    "GlDrawRangeElementsBaseVertexEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "End", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlDrawRangeElementsBaseVertexOES struct{}

func (*GlDrawRangeElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlDrawRangeElementsBaseVertexOES)(nil)
}
func doEncodeGlDrawRangeElementsBaseVertexOES(e binary.Encoder, o *GlDrawRangeElementsBaseVertexOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Start)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.End)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Basevertex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlDrawRangeElementsBaseVertexOES(d binary.Decoder, o *GlDrawRangeElementsBaseVertexOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Start = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.End = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Basevertex = GLint(obj)
	}
	return nil
}
func doSkipGlDrawRangeElementsBaseVertexOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) ID() binary.ID {
	return binaryIDGlDrawRangeElementsBaseVertexOES
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) New() binary.Object {
	return &GlDrawRangeElementsBaseVertexOES{}
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlDrawRangeElementsBaseVertexOES(e, obj.(*GlDrawRangeElementsBaseVertexOES))
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlDrawRangeElementsBaseVertexOES{}
	return obj, doDecodeGlDrawRangeElementsBaseVertexOES(d, obj)
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlDrawRangeElementsBaseVertexOES(d, obj.(*GlDrawRangeElementsBaseVertexOES))
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) Skip(d binary.Decoder) error {
	return doSkipGlDrawRangeElementsBaseVertexOES(d)
}
func (*binaryClassGlDrawRangeElementsBaseVertexOES) Schema() *schema.Class {
	return schemaGlDrawRangeElementsBaseVertexOES
}

var schemaGlDrawRangeElementsBaseVertexOES = &schema.Class{
	TypeID:  binaryIDGlDrawRangeElementsBaseVertexOES,
	Package: "gles",
	Name:    "GlDrawRangeElementsBaseVertexOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "End", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Basevertex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlEGLImageTargetRenderbufferStorageOES struct{}

func (*GlEGLImageTargetRenderbufferStorageOES) Class() binary.Class {
	return (*binaryClassGlEGLImageTargetRenderbufferStorageOES)(nil)
}
func doEncodeGlEGLImageTargetRenderbufferStorageOES(e binary.Encoder, o *GlEGLImageTargetRenderbufferStorageOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Value(&o.Image); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder, o *GlEGLImageTargetRenderbufferStorageOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if err := d.Value(&o.Image); err != nil {
		return err
	}
	return nil
}
func doSkipGlEGLImageTargetRenderbufferStorageOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLeglImageOES)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) ID() binary.ID {
	return binaryIDGlEGLImageTargetRenderbufferStorageOES
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) New() binary.Object {
	return &GlEGLImageTargetRenderbufferStorageOES{}
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEGLImageTargetRenderbufferStorageOES(e, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEGLImageTargetRenderbufferStorageOES{}
	return obj, doDecodeGlEGLImageTargetRenderbufferStorageOES(d, obj)
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEGLImageTargetRenderbufferStorageOES(d, obj.(*GlEGLImageTargetRenderbufferStorageOES))
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Skip(d binary.Decoder) error {
	return doSkipGlEGLImageTargetRenderbufferStorageOES(d)
}
func (*binaryClassGlEGLImageTargetRenderbufferStorageOES) Schema() *schema.Class {
	return schemaGlEGLImageTargetRenderbufferStorageOES
}

var schemaGlEGLImageTargetRenderbufferStorageOES = &schema.Class{
	TypeID:  binaryIDGlEGLImageTargetRenderbufferStorageOES,
	Package: "gles",
	Name:    "GlEGLImageTargetRenderbufferStorageOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Image", Type: &schema.Struct{Name: "GLeglImageOES", ID: (*GLeglImageOES)(nil).Class().ID()}},
	},
}

type binaryClassGlEGLImageTargetTexture2DOES struct{}

func (*GlEGLImageTargetTexture2DOES) Class() binary.Class {
	return (*binaryClassGlEGLImageTargetTexture2DOES)(nil)
}
func doEncodeGlEGLImageTargetTexture2DOES(e binary.Encoder, o *GlEGLImageTargetTexture2DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Value(&o.Image); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEGLImageTargetTexture2DOES(d binary.Decoder, o *GlEGLImageTargetTexture2DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if err := d.Value(&o.Image); err != nil {
		return err
	}
	return nil
}
func doSkipGlEGLImageTargetTexture2DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLeglImageOES)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEGLImageTargetTexture2DOES) ID() binary.ID {
	return binaryIDGlEGLImageTargetTexture2DOES
}
func (*binaryClassGlEGLImageTargetTexture2DOES) New() binary.Object {
	return &GlEGLImageTargetTexture2DOES{}
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEGLImageTargetTexture2DOES(e, obj.(*GlEGLImageTargetTexture2DOES))
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEGLImageTargetTexture2DOES{}
	return obj, doDecodeGlEGLImageTargetTexture2DOES(d, obj)
}
func (*binaryClassGlEGLImageTargetTexture2DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEGLImageTargetTexture2DOES(d, obj.(*GlEGLImageTargetTexture2DOES))
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Skip(d binary.Decoder) error {
	return doSkipGlEGLImageTargetTexture2DOES(d)
}
func (*binaryClassGlEGLImageTargetTexture2DOES) Schema() *schema.Class {
	return schemaGlEGLImageTargetTexture2DOES
}

var schemaGlEGLImageTargetTexture2DOES = &schema.Class{
	TypeID:  binaryIDGlEGLImageTargetTexture2DOES,
	Package: "gles",
	Name:    "GlEGLImageTargetTexture2DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Image", Type: &schema.Struct{Name: "GLeglImageOES", ID: (*GLeglImageOES)(nil).Class().ID()}},
	},
}

type binaryClassGlEnable struct{}

func (*GlEnable) Class() binary.Class {
	return (*binaryClassGlEnable)(nil)
}
func doEncodeGlEnable(e binary.Encoder, o *GlEnable) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Capability)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnable(d binary.Decoder, o *GlEnable) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Capability = GLenum(obj)
	}
	return nil
}
func doSkipGlEnable(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnable) ID() binary.ID      { return binaryIDGlEnable }
func (*binaryClassGlEnable) New() binary.Object { return &GlEnable{} }
func (*binaryClassGlEnable) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnable(e, obj.(*GlEnable))
}
func (*binaryClassGlEnable) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnable{}
	return obj, doDecodeGlEnable(d, obj)
}
func (*binaryClassGlEnable) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnable(d, obj.(*GlEnable))
}
func (*binaryClassGlEnable) Skip(d binary.Decoder) error { return doSkipGlEnable(d) }
func (*binaryClassGlEnable) Schema() *schema.Class       { return schemaGlEnable }

var schemaGlEnable = &schema.Class{
	TypeID:  binaryIDGlEnable,
	Package: "gles",
	Name:    "GlEnable",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Capability", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlEnableDriverControlQCOM struct{}

func (*GlEnableDriverControlQCOM) Class() binary.Class {
	return (*binaryClassGlEnableDriverControlQCOM)(nil)
}
func doEncodeGlEnableDriverControlQCOM(e binary.Encoder, o *GlEnableDriverControlQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DriverControl)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnableDriverControlQCOM(d binary.Decoder, o *GlEnableDriverControlQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DriverControl = GLuint(obj)
	}
	return nil
}
func doSkipGlEnableDriverControlQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnableDriverControlQCOM) ID() binary.ID      { return binaryIDGlEnableDriverControlQCOM }
func (*binaryClassGlEnableDriverControlQCOM) New() binary.Object { return &GlEnableDriverControlQCOM{} }
func (*binaryClassGlEnableDriverControlQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnableDriverControlQCOM(e, obj.(*GlEnableDriverControlQCOM))
}
func (*binaryClassGlEnableDriverControlQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnableDriverControlQCOM{}
	return obj, doDecodeGlEnableDriverControlQCOM(d, obj)
}
func (*binaryClassGlEnableDriverControlQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnableDriverControlQCOM(d, obj.(*GlEnableDriverControlQCOM))
}
func (*binaryClassGlEnableDriverControlQCOM) Skip(d binary.Decoder) error {
	return doSkipGlEnableDriverControlQCOM(d)
}
func (*binaryClassGlEnableDriverControlQCOM) Schema() *schema.Class {
	return schemaGlEnableDriverControlQCOM
}

var schemaGlEnableDriverControlQCOM = &schema.Class{
	TypeID:  binaryIDGlEnableDriverControlQCOM,
	Package: "gles",
	Name:    "GlEnableDriverControlQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DriverControl", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEnableVertexAttribArray struct{}

func (*GlEnableVertexAttribArray) Class() binary.Class {
	return (*binaryClassGlEnableVertexAttribArray)(nil)
}
func doEncodeGlEnableVertexAttribArray(e binary.Encoder, o *GlEnableVertexAttribArray) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnableVertexAttribArray(d binary.Decoder, o *GlEnableVertexAttribArray) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	return nil
}
func doSkipGlEnableVertexAttribArray(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnableVertexAttribArray) ID() binary.ID      { return binaryIDGlEnableVertexAttribArray }
func (*binaryClassGlEnableVertexAttribArray) New() binary.Object { return &GlEnableVertexAttribArray{} }
func (*binaryClassGlEnableVertexAttribArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnableVertexAttribArray(e, obj.(*GlEnableVertexAttribArray))
}
func (*binaryClassGlEnableVertexAttribArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnableVertexAttribArray{}
	return obj, doDecodeGlEnableVertexAttribArray(d, obj)
}
func (*binaryClassGlEnableVertexAttribArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnableVertexAttribArray(d, obj.(*GlEnableVertexAttribArray))
}
func (*binaryClassGlEnableVertexAttribArray) Skip(d binary.Decoder) error {
	return doSkipGlEnableVertexAttribArray(d)
}
func (*binaryClassGlEnableVertexAttribArray) Schema() *schema.Class {
	return schemaGlEnableVertexAttribArray
}

var schemaGlEnableVertexAttribArray = &schema.Class{
	TypeID:  binaryIDGlEnableVertexAttribArray,
	Package: "gles",
	Name:    "GlEnableVertexAttribArray",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
	},
}

type binaryClassGlEnableiEXT struct{}

func (*GlEnableiEXT) Class() binary.Class {
	return (*binaryClassGlEnableiEXT)(nil)
}
func doEncodeGlEnableiEXT(e binary.Encoder, o *GlEnableiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnableiEXT(d binary.Decoder, o *GlEnableiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlEnableiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnableiEXT) ID() binary.ID      { return binaryIDGlEnableiEXT }
func (*binaryClassGlEnableiEXT) New() binary.Object { return &GlEnableiEXT{} }
func (*binaryClassGlEnableiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnableiEXT(e, obj.(*GlEnableiEXT))
}
func (*binaryClassGlEnableiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnableiEXT{}
	return obj, doDecodeGlEnableiEXT(d, obj)
}
func (*binaryClassGlEnableiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnableiEXT(d, obj.(*GlEnableiEXT))
}
func (*binaryClassGlEnableiEXT) Skip(d binary.Decoder) error { return doSkipGlEnableiEXT(d) }
func (*binaryClassGlEnableiEXT) Schema() *schema.Class       { return schemaGlEnableiEXT }

var schemaGlEnableiEXT = &schema.Class{
	TypeID:  binaryIDGlEnableiEXT,
	Package: "gles",
	Name:    "GlEnableiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEnableiNV struct{}

func (*GlEnableiNV) Class() binary.Class {
	return (*binaryClassGlEnableiNV)(nil)
}
func doEncodeGlEnableiNV(e binary.Encoder, o *GlEnableiNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnableiNV(d binary.Decoder, o *GlEnableiNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlEnableiNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnableiNV) ID() binary.ID      { return binaryIDGlEnableiNV }
func (*binaryClassGlEnableiNV) New() binary.Object { return &GlEnableiNV{} }
func (*binaryClassGlEnableiNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnableiNV(e, obj.(*GlEnableiNV))
}
func (*binaryClassGlEnableiNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnableiNV{}
	return obj, doDecodeGlEnableiNV(d, obj)
}
func (*binaryClassGlEnableiNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnableiNV(d, obj.(*GlEnableiNV))
}
func (*binaryClassGlEnableiNV) Skip(d binary.Decoder) error { return doSkipGlEnableiNV(d) }
func (*binaryClassGlEnableiNV) Schema() *schema.Class       { return schemaGlEnableiNV }

var schemaGlEnableiNV = &schema.Class{
	TypeID:  binaryIDGlEnableiNV,
	Package: "gles",
	Name:    "GlEnableiNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEnableiOES struct{}

func (*GlEnableiOES) Class() binary.Class {
	return (*binaryClassGlEnableiOES)(nil)
}
func doEncodeGlEnableiOES(e binary.Encoder, o *GlEnableiOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEnableiOES(d binary.Decoder, o *GlEnableiOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	return nil
}
func doSkipGlEnableiOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEnableiOES) ID() binary.ID      { return binaryIDGlEnableiOES }
func (*binaryClassGlEnableiOES) New() binary.Object { return &GlEnableiOES{} }
func (*binaryClassGlEnableiOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEnableiOES(e, obj.(*GlEnableiOES))
}
func (*binaryClassGlEnableiOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEnableiOES{}
	return obj, doDecodeGlEnableiOES(d, obj)
}
func (*binaryClassGlEnableiOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEnableiOES(d, obj.(*GlEnableiOES))
}
func (*binaryClassGlEnableiOES) Skip(d binary.Decoder) error { return doSkipGlEnableiOES(d) }
func (*binaryClassGlEnableiOES) Schema() *schema.Class       { return schemaGlEnableiOES }

var schemaGlEnableiOES = &schema.Class{
	TypeID:  binaryIDGlEnableiOES,
	Package: "gles",
	Name:    "GlEnableiOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEndConditionalRenderNV struct{}

func (*GlEndConditionalRenderNV) Class() binary.Class {
	return (*binaryClassGlEndConditionalRenderNV)(nil)
}
func doEncodeGlEndConditionalRenderNV(e binary.Encoder, o *GlEndConditionalRenderNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndConditionalRenderNV(d binary.Decoder, o *GlEndConditionalRenderNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlEndConditionalRenderNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndConditionalRenderNV) ID() binary.ID      { return binaryIDGlEndConditionalRenderNV }
func (*binaryClassGlEndConditionalRenderNV) New() binary.Object { return &GlEndConditionalRenderNV{} }
func (*binaryClassGlEndConditionalRenderNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndConditionalRenderNV(e, obj.(*GlEndConditionalRenderNV))
}
func (*binaryClassGlEndConditionalRenderNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndConditionalRenderNV{}
	return obj, doDecodeGlEndConditionalRenderNV(d, obj)
}
func (*binaryClassGlEndConditionalRenderNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndConditionalRenderNV(d, obj.(*GlEndConditionalRenderNV))
}
func (*binaryClassGlEndConditionalRenderNV) Skip(d binary.Decoder) error {
	return doSkipGlEndConditionalRenderNV(d)
}
func (*binaryClassGlEndConditionalRenderNV) Schema() *schema.Class {
	return schemaGlEndConditionalRenderNV
}

var schemaGlEndConditionalRenderNV = &schema.Class{
	TypeID:  binaryIDGlEndConditionalRenderNV,
	Package: "gles",
	Name:    "GlEndConditionalRenderNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlEndPerfMonitorAMD struct{}

func (*GlEndPerfMonitorAMD) Class() binary.Class {
	return (*binaryClassGlEndPerfMonitorAMD)(nil)
}
func doEncodeGlEndPerfMonitorAMD(e binary.Encoder, o *GlEndPerfMonitorAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Monitor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndPerfMonitorAMD(d binary.Decoder, o *GlEndPerfMonitorAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Monitor = GLuint(obj)
	}
	return nil
}
func doSkipGlEndPerfMonitorAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndPerfMonitorAMD) ID() binary.ID      { return binaryIDGlEndPerfMonitorAMD }
func (*binaryClassGlEndPerfMonitorAMD) New() binary.Object { return &GlEndPerfMonitorAMD{} }
func (*binaryClassGlEndPerfMonitorAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndPerfMonitorAMD(e, obj.(*GlEndPerfMonitorAMD))
}
func (*binaryClassGlEndPerfMonitorAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndPerfMonitorAMD{}
	return obj, doDecodeGlEndPerfMonitorAMD(d, obj)
}
func (*binaryClassGlEndPerfMonitorAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndPerfMonitorAMD(d, obj.(*GlEndPerfMonitorAMD))
}
func (*binaryClassGlEndPerfMonitorAMD) Skip(d binary.Decoder) error {
	return doSkipGlEndPerfMonitorAMD(d)
}
func (*binaryClassGlEndPerfMonitorAMD) Schema() *schema.Class { return schemaGlEndPerfMonitorAMD }

var schemaGlEndPerfMonitorAMD = &schema.Class{
	TypeID:  binaryIDGlEndPerfMonitorAMD,
	Package: "gles",
	Name:    "GlEndPerfMonitorAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Monitor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEndPerfQueryINTEL struct{}

func (*GlEndPerfQueryINTEL) Class() binary.Class {
	return (*binaryClassGlEndPerfQueryINTEL)(nil)
}
func doEncodeGlEndPerfQueryINTEL(e binary.Encoder, o *GlEndPerfQueryINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryHandle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndPerfQueryINTEL(d binary.Decoder, o *GlEndPerfQueryINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryHandle = GLuint(obj)
	}
	return nil
}
func doSkipGlEndPerfQueryINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndPerfQueryINTEL) ID() binary.ID      { return binaryIDGlEndPerfQueryINTEL }
func (*binaryClassGlEndPerfQueryINTEL) New() binary.Object { return &GlEndPerfQueryINTEL{} }
func (*binaryClassGlEndPerfQueryINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndPerfQueryINTEL(e, obj.(*GlEndPerfQueryINTEL))
}
func (*binaryClassGlEndPerfQueryINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndPerfQueryINTEL{}
	return obj, doDecodeGlEndPerfQueryINTEL(d, obj)
}
func (*binaryClassGlEndPerfQueryINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndPerfQueryINTEL(d, obj.(*GlEndPerfQueryINTEL))
}
func (*binaryClassGlEndPerfQueryINTEL) Skip(d binary.Decoder) error {
	return doSkipGlEndPerfQueryINTEL(d)
}
func (*binaryClassGlEndPerfQueryINTEL) Schema() *schema.Class { return schemaGlEndPerfQueryINTEL }

var schemaGlEndPerfQueryINTEL = &schema.Class{
	TypeID:  binaryIDGlEndPerfQueryINTEL,
	Package: "gles",
	Name:    "GlEndPerfQueryINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryHandle", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlEndQuery struct{}

func (*GlEndQuery) Class() binary.Class {
	return (*binaryClassGlEndQuery)(nil)
}
func doEncodeGlEndQuery(e binary.Encoder, o *GlEndQuery) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndQuery(d binary.Decoder, o *GlEndQuery) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	return nil
}
func doSkipGlEndQuery(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndQuery) ID() binary.ID      { return binaryIDGlEndQuery }
func (*binaryClassGlEndQuery) New() binary.Object { return &GlEndQuery{} }
func (*binaryClassGlEndQuery) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndQuery(e, obj.(*GlEndQuery))
}
func (*binaryClassGlEndQuery) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndQuery{}
	return obj, doDecodeGlEndQuery(d, obj)
}
func (*binaryClassGlEndQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndQuery(d, obj.(*GlEndQuery))
}
func (*binaryClassGlEndQuery) Skip(d binary.Decoder) error { return doSkipGlEndQuery(d) }
func (*binaryClassGlEndQuery) Schema() *schema.Class       { return schemaGlEndQuery }

var schemaGlEndQuery = &schema.Class{
	TypeID:  binaryIDGlEndQuery,
	Package: "gles",
	Name:    "GlEndQuery",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlEndQueryEXT struct{}

func (*GlEndQueryEXT) Class() binary.Class {
	return (*binaryClassGlEndQueryEXT)(nil)
}
func doEncodeGlEndQueryEXT(e binary.Encoder, o *GlEndQueryEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndQueryEXT(d binary.Decoder, o *GlEndQueryEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	return nil
}
func doSkipGlEndQueryEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndQueryEXT) ID() binary.ID      { return binaryIDGlEndQueryEXT }
func (*binaryClassGlEndQueryEXT) New() binary.Object { return &GlEndQueryEXT{} }
func (*binaryClassGlEndQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndQueryEXT(e, obj.(*GlEndQueryEXT))
}
func (*binaryClassGlEndQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndQueryEXT{}
	return obj, doDecodeGlEndQueryEXT(d, obj)
}
func (*binaryClassGlEndQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndQueryEXT(d, obj.(*GlEndQueryEXT))
}
func (*binaryClassGlEndQueryEXT) Skip(d binary.Decoder) error { return doSkipGlEndQueryEXT(d) }
func (*binaryClassGlEndQueryEXT) Schema() *schema.Class       { return schemaGlEndQueryEXT }

var schemaGlEndQueryEXT = &schema.Class{
	TypeID:  binaryIDGlEndQueryEXT,
	Package: "gles",
	Name:    "GlEndQueryEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlEndTilingQCOM struct{}

func (*GlEndTilingQCOM) Class() binary.Class {
	return (*binaryClassGlEndTilingQCOM)(nil)
}
func doEncodeGlEndTilingQCOM(e binary.Encoder, o *GlEndTilingQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PreserveMask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndTilingQCOM(d binary.Decoder, o *GlEndTilingQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PreserveMask = GLbitfield(obj)
	}
	return nil
}
func doSkipGlEndTilingQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndTilingQCOM) ID() binary.ID      { return binaryIDGlEndTilingQCOM }
func (*binaryClassGlEndTilingQCOM) New() binary.Object { return &GlEndTilingQCOM{} }
func (*binaryClassGlEndTilingQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndTilingQCOM(e, obj.(*GlEndTilingQCOM))
}
func (*binaryClassGlEndTilingQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndTilingQCOM{}
	return obj, doDecodeGlEndTilingQCOM(d, obj)
}
func (*binaryClassGlEndTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndTilingQCOM(d, obj.(*GlEndTilingQCOM))
}
func (*binaryClassGlEndTilingQCOM) Skip(d binary.Decoder) error { return doSkipGlEndTilingQCOM(d) }
func (*binaryClassGlEndTilingQCOM) Schema() *schema.Class       { return schemaGlEndTilingQCOM }

var schemaGlEndTilingQCOM = &schema.Class{
	TypeID:  binaryIDGlEndTilingQCOM,
	Package: "gles",
	Name:    "GlEndTilingQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "PreserveMask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlEndTransformFeedback struct{}

func (*GlEndTransformFeedback) Class() binary.Class {
	return (*binaryClassGlEndTransformFeedback)(nil)
}
func doEncodeGlEndTransformFeedback(e binary.Encoder, o *GlEndTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlEndTransformFeedback(d binary.Decoder, o *GlEndTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlEndTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlEndTransformFeedback) ID() binary.ID      { return binaryIDGlEndTransformFeedback }
func (*binaryClassGlEndTransformFeedback) New() binary.Object { return &GlEndTransformFeedback{} }
func (*binaryClassGlEndTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlEndTransformFeedback(e, obj.(*GlEndTransformFeedback))
}
func (*binaryClassGlEndTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlEndTransformFeedback{}
	return obj, doDecodeGlEndTransformFeedback(d, obj)
}
func (*binaryClassGlEndTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlEndTransformFeedback(d, obj.(*GlEndTransformFeedback))
}
func (*binaryClassGlEndTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlEndTransformFeedback(d)
}
func (*binaryClassGlEndTransformFeedback) Schema() *schema.Class { return schemaGlEndTransformFeedback }

var schemaGlEndTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlEndTransformFeedback,
	Package: "gles",
	Name:    "GlEndTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassVoidᵖᵖ struct{}

func (*Voidᵖᵖ) Class() binary.Class {
	return (*binaryClassVoidᵖᵖ)(nil)
}
func doEncodeVoidᵖᵖ(e binary.Encoder, o *Voidᵖᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᵖᵖ(d binary.Decoder, o *Voidᵖᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᵖᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᵖᵖ) ID() binary.ID      { return binaryIDVoidᵖᵖ }
func (*binaryClassVoidᵖᵖ) New() binary.Object { return &Voidᵖᵖ{} }
func (*binaryClassVoidᵖᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᵖᵖ(e, obj.(*Voidᵖᵖ))
}
func (*binaryClassVoidᵖᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᵖᵖ{}
	return obj, doDecodeVoidᵖᵖ(d, obj)
}
func (*binaryClassVoidᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᵖᵖ(d, obj.(*Voidᵖᵖ))
}
func (*binaryClassVoidᵖᵖ) Skip(d binary.Decoder) error { return doSkipVoidᵖᵖ(d) }
func (*binaryClassVoidᵖᵖ) Schema() *schema.Class       { return schemaVoidᵖᵖ }

var schemaVoidᵖᵖ = &schema.Class{
	TypeID:  binaryIDVoidᵖᵖ,
	Package: "gles",
	Name:    "Voidᵖᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetBufferPointervQCOM struct{}

func (*GlExtGetBufferPointervQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetBufferPointervQCOM)(nil)
}
func doEncodeGlExtGetBufferPointervQCOM(e binary.Encoder, o *GlExtGetBufferPointervQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetBufferPointervQCOM(d binary.Decoder, o *GlExtGetBufferPointervQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetBufferPointervQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetBufferPointervQCOM) ID() binary.ID {
	return binaryIDGlExtGetBufferPointervQCOM
}
func (*binaryClassGlExtGetBufferPointervQCOM) New() binary.Object {
	return &GlExtGetBufferPointervQCOM{}
}
func (*binaryClassGlExtGetBufferPointervQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetBufferPointervQCOM(e, obj.(*GlExtGetBufferPointervQCOM))
}
func (*binaryClassGlExtGetBufferPointervQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetBufferPointervQCOM{}
	return obj, doDecodeGlExtGetBufferPointervQCOM(d, obj)
}
func (*binaryClassGlExtGetBufferPointervQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetBufferPointervQCOM(d, obj.(*GlExtGetBufferPointervQCOM))
}
func (*binaryClassGlExtGetBufferPointervQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetBufferPointervQCOM(d)
}
func (*binaryClassGlExtGetBufferPointervQCOM) Schema() *schema.Class {
	return schemaGlExtGetBufferPointervQCOM
}

var schemaGlExtGetBufferPointervQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetBufferPointervQCOM,
	Package: "gles",
	Name:    "GlExtGetBufferPointervQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "Voidᵖᵖ", ID: (*Voidᵖᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetBuffersQCOM struct{}

func (*GlExtGetBuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetBuffersQCOM)(nil)
}
func doEncodeGlExtGetBuffersQCOM(e binary.Encoder, o *GlExtGetBuffersQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Buffers); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxBuffers)); err != nil {
		return err
	}
	if err := e.Value(&o.NumBuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetBuffersQCOM(d binary.Decoder, o *GlExtGetBuffersQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Buffers); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxBuffers = GLint(obj)
	}
	if err := d.Value(&o.NumBuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetBuffersQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*BufferIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetBuffersQCOM) ID() binary.ID      { return binaryIDGlExtGetBuffersQCOM }
func (*binaryClassGlExtGetBuffersQCOM) New() binary.Object { return &GlExtGetBuffersQCOM{} }
func (*binaryClassGlExtGetBuffersQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetBuffersQCOM(e, obj.(*GlExtGetBuffersQCOM))
}
func (*binaryClassGlExtGetBuffersQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetBuffersQCOM{}
	return obj, doDecodeGlExtGetBuffersQCOM(d, obj)
}
func (*binaryClassGlExtGetBuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetBuffersQCOM(d, obj.(*GlExtGetBuffersQCOM))
}
func (*binaryClassGlExtGetBuffersQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetBuffersQCOM(d)
}
func (*binaryClassGlExtGetBuffersQCOM) Schema() *schema.Class { return schemaGlExtGetBuffersQCOM }

var schemaGlExtGetBuffersQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetBuffersQCOM,
	Package: "gles",
	Name:    "GlExtGetBuffersQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffers", Type: &schema.Struct{Name: "BufferIdᵖ", ID: (*BufferIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxBuffers", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumBuffers", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetFramebuffersQCOM struct{}

func (*GlExtGetFramebuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetFramebuffersQCOM)(nil)
}
func doEncodeGlExtGetFramebuffersQCOM(e binary.Encoder, o *GlExtGetFramebuffersQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Framebuffers); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxFramebuffers)); err != nil {
		return err
	}
	if err := e.Value(&o.NumFramebuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetFramebuffersQCOM(d binary.Decoder, o *GlExtGetFramebuffersQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Framebuffers); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxFramebuffers = GLint(obj)
	}
	if err := d.Value(&o.NumFramebuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetFramebuffersQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*FramebufferIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetFramebuffersQCOM) ID() binary.ID      { return binaryIDGlExtGetFramebuffersQCOM }
func (*binaryClassGlExtGetFramebuffersQCOM) New() binary.Object { return &GlExtGetFramebuffersQCOM{} }
func (*binaryClassGlExtGetFramebuffersQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetFramebuffersQCOM(e, obj.(*GlExtGetFramebuffersQCOM))
}
func (*binaryClassGlExtGetFramebuffersQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetFramebuffersQCOM{}
	return obj, doDecodeGlExtGetFramebuffersQCOM(d, obj)
}
func (*binaryClassGlExtGetFramebuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetFramebuffersQCOM(d, obj.(*GlExtGetFramebuffersQCOM))
}
func (*binaryClassGlExtGetFramebuffersQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetFramebuffersQCOM(d)
}
func (*binaryClassGlExtGetFramebuffersQCOM) Schema() *schema.Class {
	return schemaGlExtGetFramebuffersQCOM
}

var schemaGlExtGetFramebuffersQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetFramebuffersQCOM,
	Package: "gles",
	Name:    "GlExtGetFramebuffersQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Framebuffers", Type: &schema.Struct{Name: "FramebufferIdᵖ", ID: (*FramebufferIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxFramebuffers", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumFramebuffers", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetProgramBinarySourceQCOM struct{}

func (*GlExtGetProgramBinarySourceQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetProgramBinarySourceQCOM)(nil)
}
func doEncodeGlExtGetProgramBinarySourceQCOM(e binary.Encoder, o *GlExtGetProgramBinarySourceQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shadertype)); err != nil {
		return err
	}
	if err := e.Value(&o.Source); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetProgramBinarySourceQCOM(d binary.Decoder, o *GlExtGetProgramBinarySourceQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shadertype = GLenum(obj)
	}
	if err := d.Value(&o.Source); err != nil {
		return err
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetProgramBinarySourceQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) ID() binary.ID {
	return binaryIDGlExtGetProgramBinarySourceQCOM
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) New() binary.Object {
	return &GlExtGetProgramBinarySourceQCOM{}
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetProgramBinarySourceQCOM(e, obj.(*GlExtGetProgramBinarySourceQCOM))
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetProgramBinarySourceQCOM{}
	return obj, doDecodeGlExtGetProgramBinarySourceQCOM(d, obj)
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetProgramBinarySourceQCOM(d, obj.(*GlExtGetProgramBinarySourceQCOM))
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetProgramBinarySourceQCOM(d)
}
func (*binaryClassGlExtGetProgramBinarySourceQCOM) Schema() *schema.Class {
	return schemaGlExtGetProgramBinarySourceQCOM
}

var schemaGlExtGetProgramBinarySourceQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetProgramBinarySourceQCOM,
	Package: "gles",
	Name:    "GlExtGetProgramBinarySourceQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Shadertype", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Source", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassProgramIdᵖ struct{}

func (*ProgramIdᵖ) Class() binary.Class {
	return (*binaryClassProgramIdᵖ)(nil)
}
func doEncodeProgramIdᵖ(e binary.Encoder, o *ProgramIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeProgramIdᵖ(d binary.Decoder, o *ProgramIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipProgramIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassProgramIdᵖ) ID() binary.ID      { return binaryIDProgramIdᵖ }
func (*binaryClassProgramIdᵖ) New() binary.Object { return &ProgramIdᵖ{} }
func (*binaryClassProgramIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeProgramIdᵖ(e, obj.(*ProgramIdᵖ))
}
func (*binaryClassProgramIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ProgramIdᵖ{}
	return obj, doDecodeProgramIdᵖ(d, obj)
}
func (*binaryClassProgramIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeProgramIdᵖ(d, obj.(*ProgramIdᵖ))
}
func (*binaryClassProgramIdᵖ) Skip(d binary.Decoder) error { return doSkipProgramIdᵖ(d) }
func (*binaryClassProgramIdᵖ) Schema() *schema.Class       { return schemaProgramIdᵖ }

var schemaProgramIdᵖ = &schema.Class{
	TypeID:  binaryIDProgramIdᵖ,
	Package: "gles",
	Name:    "ProgramIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetProgramsQCOM struct{}

func (*GlExtGetProgramsQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetProgramsQCOM)(nil)
}
func doEncodeGlExtGetProgramsQCOM(e binary.Encoder, o *GlExtGetProgramsQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Programs); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxPrograms)); err != nil {
		return err
	}
	if err := e.Value(&o.NumPrograms); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetProgramsQCOM(d binary.Decoder, o *GlExtGetProgramsQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Programs); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxPrograms = GLint(obj)
	}
	if err := d.Value(&o.NumPrograms); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetProgramsQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ProgramIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetProgramsQCOM) ID() binary.ID      { return binaryIDGlExtGetProgramsQCOM }
func (*binaryClassGlExtGetProgramsQCOM) New() binary.Object { return &GlExtGetProgramsQCOM{} }
func (*binaryClassGlExtGetProgramsQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetProgramsQCOM(e, obj.(*GlExtGetProgramsQCOM))
}
func (*binaryClassGlExtGetProgramsQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetProgramsQCOM{}
	return obj, doDecodeGlExtGetProgramsQCOM(d, obj)
}
func (*binaryClassGlExtGetProgramsQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetProgramsQCOM(d, obj.(*GlExtGetProgramsQCOM))
}
func (*binaryClassGlExtGetProgramsQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetProgramsQCOM(d)
}
func (*binaryClassGlExtGetProgramsQCOM) Schema() *schema.Class { return schemaGlExtGetProgramsQCOM }

var schemaGlExtGetProgramsQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetProgramsQCOM,
	Package: "gles",
	Name:    "GlExtGetProgramsQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Programs", Type: &schema.Struct{Name: "ProgramIdᵖ", ID: (*ProgramIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxPrograms", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumPrograms", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassRenderbufferIdᵖ struct{}

func (*RenderbufferIdᵖ) Class() binary.Class {
	return (*binaryClassRenderbufferIdᵖ)(nil)
}
func doEncodeRenderbufferIdᵖ(e binary.Encoder, o *RenderbufferIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderbufferIdᵖ(d binary.Decoder, o *RenderbufferIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipRenderbufferIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderbufferIdᵖ) ID() binary.ID      { return binaryIDRenderbufferIdᵖ }
func (*binaryClassRenderbufferIdᵖ) New() binary.Object { return &RenderbufferIdᵖ{} }
func (*binaryClassRenderbufferIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderbufferIdᵖ(e, obj.(*RenderbufferIdᵖ))
}
func (*binaryClassRenderbufferIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderbufferIdᵖ{}
	return obj, doDecodeRenderbufferIdᵖ(d, obj)
}
func (*binaryClassRenderbufferIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderbufferIdᵖ(d, obj.(*RenderbufferIdᵖ))
}
func (*binaryClassRenderbufferIdᵖ) Skip(d binary.Decoder) error { return doSkipRenderbufferIdᵖ(d) }
func (*binaryClassRenderbufferIdᵖ) Schema() *schema.Class       { return schemaRenderbufferIdᵖ }

var schemaRenderbufferIdᵖ = &schema.Class{
	TypeID:  binaryIDRenderbufferIdᵖ,
	Package: "gles",
	Name:    "RenderbufferIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetRenderbuffersQCOM struct{}

func (*GlExtGetRenderbuffersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetRenderbuffersQCOM)(nil)
}
func doEncodeGlExtGetRenderbuffersQCOM(e binary.Encoder, o *GlExtGetRenderbuffersQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Renderbuffers); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxRenderbuffers)); err != nil {
		return err
	}
	if err := e.Value(&o.NumRenderbuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetRenderbuffersQCOM(d binary.Decoder, o *GlExtGetRenderbuffersQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Renderbuffers); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxRenderbuffers = GLint(obj)
	}
	if err := d.Value(&o.NumRenderbuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetRenderbuffersQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*RenderbufferIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetRenderbuffersQCOM) ID() binary.ID      { return binaryIDGlExtGetRenderbuffersQCOM }
func (*binaryClassGlExtGetRenderbuffersQCOM) New() binary.Object { return &GlExtGetRenderbuffersQCOM{} }
func (*binaryClassGlExtGetRenderbuffersQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetRenderbuffersQCOM(e, obj.(*GlExtGetRenderbuffersQCOM))
}
func (*binaryClassGlExtGetRenderbuffersQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetRenderbuffersQCOM{}
	return obj, doDecodeGlExtGetRenderbuffersQCOM(d, obj)
}
func (*binaryClassGlExtGetRenderbuffersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetRenderbuffersQCOM(d, obj.(*GlExtGetRenderbuffersQCOM))
}
func (*binaryClassGlExtGetRenderbuffersQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetRenderbuffersQCOM(d)
}
func (*binaryClassGlExtGetRenderbuffersQCOM) Schema() *schema.Class {
	return schemaGlExtGetRenderbuffersQCOM
}

var schemaGlExtGetRenderbuffersQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetRenderbuffersQCOM,
	Package: "gles",
	Name:    "GlExtGetRenderbuffersQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Renderbuffers", Type: &schema.Struct{Name: "RenderbufferIdᵖ", ID: (*RenderbufferIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxRenderbuffers", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumRenderbuffers", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassShaderIdᵖ struct{}

func (*ShaderIdᵖ) Class() binary.Class {
	return (*binaryClassShaderIdᵖ)(nil)
}
func doEncodeShaderIdᵖ(e binary.Encoder, o *ShaderIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeShaderIdᵖ(d binary.Decoder, o *ShaderIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipShaderIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassShaderIdᵖ) ID() binary.ID      { return binaryIDShaderIdᵖ }
func (*binaryClassShaderIdᵖ) New() binary.Object { return &ShaderIdᵖ{} }
func (*binaryClassShaderIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeShaderIdᵖ(e, obj.(*ShaderIdᵖ))
}
func (*binaryClassShaderIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ShaderIdᵖ{}
	return obj, doDecodeShaderIdᵖ(d, obj)
}
func (*binaryClassShaderIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeShaderIdᵖ(d, obj.(*ShaderIdᵖ))
}
func (*binaryClassShaderIdᵖ) Skip(d binary.Decoder) error { return doSkipShaderIdᵖ(d) }
func (*binaryClassShaderIdᵖ) Schema() *schema.Class       { return schemaShaderIdᵖ }

var schemaShaderIdᵖ = &schema.Class{
	TypeID:  binaryIDShaderIdᵖ,
	Package: "gles",
	Name:    "ShaderIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetShadersQCOM struct{}

func (*GlExtGetShadersQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetShadersQCOM)(nil)
}
func doEncodeGlExtGetShadersQCOM(e binary.Encoder, o *GlExtGetShadersQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Shaders); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxShaders)); err != nil {
		return err
	}
	if err := e.Value(&o.NumShaders); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetShadersQCOM(d binary.Decoder, o *GlExtGetShadersQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Shaders); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxShaders = GLint(obj)
	}
	if err := d.Value(&o.NumShaders); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetShadersQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ShaderIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetShadersQCOM) ID() binary.ID      { return binaryIDGlExtGetShadersQCOM }
func (*binaryClassGlExtGetShadersQCOM) New() binary.Object { return &GlExtGetShadersQCOM{} }
func (*binaryClassGlExtGetShadersQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetShadersQCOM(e, obj.(*GlExtGetShadersQCOM))
}
func (*binaryClassGlExtGetShadersQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetShadersQCOM{}
	return obj, doDecodeGlExtGetShadersQCOM(d, obj)
}
func (*binaryClassGlExtGetShadersQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetShadersQCOM(d, obj.(*GlExtGetShadersQCOM))
}
func (*binaryClassGlExtGetShadersQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetShadersQCOM(d)
}
func (*binaryClassGlExtGetShadersQCOM) Schema() *schema.Class { return schemaGlExtGetShadersQCOM }

var schemaGlExtGetShadersQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetShadersQCOM,
	Package: "gles",
	Name:    "GlExtGetShadersQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shaders", Type: &schema.Struct{Name: "ShaderIdᵖ", ID: (*ShaderIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxShaders", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumShaders", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetTexLevelParameterivQCOM struct{}

func (*GlExtGetTexLevelParameterivQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexLevelParameterivQCOM)(nil)
}
func doEncodeGlExtGetTexLevelParameterivQCOM(e binary.Encoder, o *GlExtGetTexLevelParameterivQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Face)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetTexLevelParameterivQCOM(d binary.Decoder, o *GlExtGetTexLevelParameterivQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Face = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetTexLevelParameterivQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) ID() binary.ID {
	return binaryIDGlExtGetTexLevelParameterivQCOM
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) New() binary.Object {
	return &GlExtGetTexLevelParameterivQCOM{}
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetTexLevelParameterivQCOM(e, obj.(*GlExtGetTexLevelParameterivQCOM))
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetTexLevelParameterivQCOM{}
	return obj, doDecodeGlExtGetTexLevelParameterivQCOM(d, obj)
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetTexLevelParameterivQCOM(d, obj.(*GlExtGetTexLevelParameterivQCOM))
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetTexLevelParameterivQCOM(d)
}
func (*binaryClassGlExtGetTexLevelParameterivQCOM) Schema() *schema.Class {
	return schemaGlExtGetTexLevelParameterivQCOM
}

var schemaGlExtGetTexLevelParameterivQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetTexLevelParameterivQCOM,
	Package: "gles",
	Name:    "GlExtGetTexLevelParameterivQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Face", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetTexSubImageQCOM struct{}

func (*GlExtGetTexSubImageQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexSubImageQCOM)(nil)
}
func doEncodeGlExtGetTexSubImageQCOM(e binary.Encoder, o *GlExtGetTexSubImageQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Texels); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetTexSubImageQCOM(d binary.Decoder, o *GlExtGetTexSubImageQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Texels); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetTexSubImageQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetTexSubImageQCOM) ID() binary.ID      { return binaryIDGlExtGetTexSubImageQCOM }
func (*binaryClassGlExtGetTexSubImageQCOM) New() binary.Object { return &GlExtGetTexSubImageQCOM{} }
func (*binaryClassGlExtGetTexSubImageQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetTexSubImageQCOM(e, obj.(*GlExtGetTexSubImageQCOM))
}
func (*binaryClassGlExtGetTexSubImageQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetTexSubImageQCOM{}
	return obj, doDecodeGlExtGetTexSubImageQCOM(d, obj)
}
func (*binaryClassGlExtGetTexSubImageQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetTexSubImageQCOM(d, obj.(*GlExtGetTexSubImageQCOM))
}
func (*binaryClassGlExtGetTexSubImageQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetTexSubImageQCOM(d)
}
func (*binaryClassGlExtGetTexSubImageQCOM) Schema() *schema.Class {
	return schemaGlExtGetTexSubImageQCOM
}

var schemaGlExtGetTexSubImageQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetTexSubImageQCOM,
	Package: "gles",
	Name:    "GlExtGetTexSubImageQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texels", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassTextureIdᵖ struct{}

func (*TextureIdᵖ) Class() binary.Class {
	return (*binaryClassTextureIdᵖ)(nil)
}
func doEncodeTextureIdᵖ(e binary.Encoder, o *TextureIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeTextureIdᵖ(d binary.Decoder, o *TextureIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipTextureIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTextureIdᵖ) ID() binary.ID      { return binaryIDTextureIdᵖ }
func (*binaryClassTextureIdᵖ) New() binary.Object { return &TextureIdᵖ{} }
func (*binaryClassTextureIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTextureIdᵖ(e, obj.(*TextureIdᵖ))
}
func (*binaryClassTextureIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TextureIdᵖ{}
	return obj, doDecodeTextureIdᵖ(d, obj)
}
func (*binaryClassTextureIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTextureIdᵖ(d, obj.(*TextureIdᵖ))
}
func (*binaryClassTextureIdᵖ) Skip(d binary.Decoder) error { return doSkipTextureIdᵖ(d) }
func (*binaryClassTextureIdᵖ) Schema() *schema.Class       { return schemaTextureIdᵖ }

var schemaTextureIdᵖ = &schema.Class{
	TypeID:  binaryIDTextureIdᵖ,
	Package: "gles",
	Name:    "TextureIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlExtGetTexturesQCOM struct{}

func (*GlExtGetTexturesQCOM) Class() binary.Class {
	return (*binaryClassGlExtGetTexturesQCOM)(nil)
}
func doEncodeGlExtGetTexturesQCOM(e binary.Encoder, o *GlExtGetTexturesQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Textures); err != nil {
		return err
	}
	if err := e.Int32(int32(o.MaxTextures)); err != nil {
		return err
	}
	if err := e.Value(&o.NumTextures); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtGetTexturesQCOM(d binary.Decoder, o *GlExtGetTexturesQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Textures); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.MaxTextures = GLint(obj)
	}
	if err := d.Value(&o.NumTextures); err != nil {
		return err
	}
	return nil
}
func doSkipGlExtGetTexturesQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*TextureIdᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtGetTexturesQCOM) ID() binary.ID      { return binaryIDGlExtGetTexturesQCOM }
func (*binaryClassGlExtGetTexturesQCOM) New() binary.Object { return &GlExtGetTexturesQCOM{} }
func (*binaryClassGlExtGetTexturesQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtGetTexturesQCOM(e, obj.(*GlExtGetTexturesQCOM))
}
func (*binaryClassGlExtGetTexturesQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtGetTexturesQCOM{}
	return obj, doDecodeGlExtGetTexturesQCOM(d, obj)
}
func (*binaryClassGlExtGetTexturesQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtGetTexturesQCOM(d, obj.(*GlExtGetTexturesQCOM))
}
func (*binaryClassGlExtGetTexturesQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtGetTexturesQCOM(d)
}
func (*binaryClassGlExtGetTexturesQCOM) Schema() *schema.Class { return schemaGlExtGetTexturesQCOM }

var schemaGlExtGetTexturesQCOM = &schema.Class{
	TypeID:  binaryIDGlExtGetTexturesQCOM,
	Package: "gles",
	Name:    "GlExtGetTexturesQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Textures", Type: &schema.Struct{Name: "TextureIdᵖ", ID: (*TextureIdᵖ)(nil).Class().ID()}},
		{Declared: "MaxTextures", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumTextures", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlExtIsProgramBinaryQCOM struct{}

func (*GlExtIsProgramBinaryQCOM) Class() binary.Class {
	return (*binaryClassGlExtIsProgramBinaryQCOM)(nil)
}
func doEncodeGlExtIsProgramBinaryQCOM(e binary.Encoder, o *GlExtIsProgramBinaryQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtIsProgramBinaryQCOM(d binary.Decoder, o *GlExtIsProgramBinaryQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlExtIsProgramBinaryQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtIsProgramBinaryQCOM) ID() binary.ID      { return binaryIDGlExtIsProgramBinaryQCOM }
func (*binaryClassGlExtIsProgramBinaryQCOM) New() binary.Object { return &GlExtIsProgramBinaryQCOM{} }
func (*binaryClassGlExtIsProgramBinaryQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtIsProgramBinaryQCOM(e, obj.(*GlExtIsProgramBinaryQCOM))
}
func (*binaryClassGlExtIsProgramBinaryQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtIsProgramBinaryQCOM{}
	return obj, doDecodeGlExtIsProgramBinaryQCOM(d, obj)
}
func (*binaryClassGlExtIsProgramBinaryQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtIsProgramBinaryQCOM(d, obj.(*GlExtIsProgramBinaryQCOM))
}
func (*binaryClassGlExtIsProgramBinaryQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtIsProgramBinaryQCOM(d)
}
func (*binaryClassGlExtIsProgramBinaryQCOM) Schema() *schema.Class {
	return schemaGlExtIsProgramBinaryQCOM
}

var schemaGlExtIsProgramBinaryQCOM = &schema.Class{
	TypeID:  binaryIDGlExtIsProgramBinaryQCOM,
	Package: "gles",
	Name:    "GlExtIsProgramBinaryQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlExtTexObjectStateOverrideiQCOM struct{}

func (*GlExtTexObjectStateOverrideiQCOM) Class() binary.Class {
	return (*binaryClassGlExtTexObjectStateOverrideiQCOM)(nil)
}
func doEncodeGlExtTexObjectStateOverrideiQCOM(e binary.Encoder, o *GlExtTexObjectStateOverrideiQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Param)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlExtTexObjectStateOverrideiQCOM(d binary.Decoder, o *GlExtTexObjectStateOverrideiQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Param = GLint(obj)
	}
	return nil
}
func doSkipGlExtTexObjectStateOverrideiQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) ID() binary.ID {
	return binaryIDGlExtTexObjectStateOverrideiQCOM
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) New() binary.Object {
	return &GlExtTexObjectStateOverrideiQCOM{}
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlExtTexObjectStateOverrideiQCOM(e, obj.(*GlExtTexObjectStateOverrideiQCOM))
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlExtTexObjectStateOverrideiQCOM{}
	return obj, doDecodeGlExtTexObjectStateOverrideiQCOM(d, obj)
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlExtTexObjectStateOverrideiQCOM(d, obj.(*GlExtTexObjectStateOverrideiQCOM))
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) Skip(d binary.Decoder) error {
	return doSkipGlExtTexObjectStateOverrideiQCOM(d)
}
func (*binaryClassGlExtTexObjectStateOverrideiQCOM) Schema() *schema.Class {
	return schemaGlExtTexObjectStateOverrideiQCOM
}

var schemaGlExtTexObjectStateOverrideiQCOM = &schema.Class{
	TypeID:  binaryIDGlExtTexObjectStateOverrideiQCOM,
	Package: "gles",
	Name:    "GlExtTexObjectStateOverrideiQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFenceSync struct{}

func (*GlFenceSync) Class() binary.Class {
	return (*binaryClassGlFenceSync)(nil)
}
func doEncodeGlFenceSync(e binary.Encoder, o *GlFenceSync) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Condition)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SyncFlags)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFenceSync(d binary.Decoder, o *GlFenceSync) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Condition = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SyncFlags = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = GLsync(obj)
	}
	return nil
}
func doSkipGlFenceSync(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFenceSync) ID() binary.ID      { return binaryIDGlFenceSync }
func (*binaryClassGlFenceSync) New() binary.Object { return &GlFenceSync{} }
func (*binaryClassGlFenceSync) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFenceSync(e, obj.(*GlFenceSync))
}
func (*binaryClassGlFenceSync) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFenceSync{}
	return obj, doDecodeGlFenceSync(d, obj)
}
func (*binaryClassGlFenceSync) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFenceSync(d, obj.(*GlFenceSync))
}
func (*binaryClassGlFenceSync) Skip(d binary.Decoder) error { return doSkipGlFenceSync(d) }
func (*binaryClassGlFenceSync) Schema() *schema.Class       { return schemaGlFenceSync }

var schemaGlFenceSync = &schema.Class{
	TypeID:  binaryIDGlFenceSync,
	Package: "gles",
	Name:    "GlFenceSync",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Condition", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "SyncFlags", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
	},
}

type binaryClassGlFenceSyncAPPLE struct{}

func (*GlFenceSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlFenceSyncAPPLE)(nil)
}
func doEncodeGlFenceSyncAPPLE(e binary.Encoder, o *GlFenceSyncAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Condition)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flag)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFenceSyncAPPLE(d binary.Decoder, o *GlFenceSyncAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Condition = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flag = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = GLsync(obj)
	}
	return nil
}
func doSkipGlFenceSyncAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFenceSyncAPPLE) ID() binary.ID      { return binaryIDGlFenceSyncAPPLE }
func (*binaryClassGlFenceSyncAPPLE) New() binary.Object { return &GlFenceSyncAPPLE{} }
func (*binaryClassGlFenceSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFenceSyncAPPLE(e, obj.(*GlFenceSyncAPPLE))
}
func (*binaryClassGlFenceSyncAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFenceSyncAPPLE{}
	return obj, doDecodeGlFenceSyncAPPLE(d, obj)
}
func (*binaryClassGlFenceSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFenceSyncAPPLE(d, obj.(*GlFenceSyncAPPLE))
}
func (*binaryClassGlFenceSyncAPPLE) Skip(d binary.Decoder) error { return doSkipGlFenceSyncAPPLE(d) }
func (*binaryClassGlFenceSyncAPPLE) Schema() *schema.Class       { return schemaGlFenceSyncAPPLE }

var schemaGlFenceSyncAPPLE = &schema.Class{
	TypeID:  binaryIDGlFenceSyncAPPLE,
	Package: "gles",
	Name:    "GlFenceSyncAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Condition", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Flag", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
	},
}

type binaryClassGlFinish struct{}

func (*GlFinish) Class() binary.Class {
	return (*binaryClassGlFinish)(nil)
}
func doEncodeGlFinish(e binary.Encoder, o *GlFinish) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFinish(d binary.Decoder, o *GlFinish) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlFinish(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFinish) ID() binary.ID      { return binaryIDGlFinish }
func (*binaryClassGlFinish) New() binary.Object { return &GlFinish{} }
func (*binaryClassGlFinish) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFinish(e, obj.(*GlFinish))
}
func (*binaryClassGlFinish) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFinish{}
	return obj, doDecodeGlFinish(d, obj)
}
func (*binaryClassGlFinish) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFinish(d, obj.(*GlFinish))
}
func (*binaryClassGlFinish) Skip(d binary.Decoder) error { return doSkipGlFinish(d) }
func (*binaryClassGlFinish) Schema() *schema.Class       { return schemaGlFinish }

var schemaGlFinish = &schema.Class{
	TypeID:  binaryIDGlFinish,
	Package: "gles",
	Name:    "GlFinish",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlFinishFenceNV struct{}

func (*GlFinishFenceNV) Class() binary.Class {
	return (*binaryClassGlFinishFenceNV)(nil)
}
func doEncodeGlFinishFenceNV(e binary.Encoder, o *GlFinishFenceNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fence)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFinishFenceNV(d binary.Decoder, o *GlFinishFenceNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fence = GLuint(obj)
	}
	return nil
}
func doSkipGlFinishFenceNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFinishFenceNV) ID() binary.ID      { return binaryIDGlFinishFenceNV }
func (*binaryClassGlFinishFenceNV) New() binary.Object { return &GlFinishFenceNV{} }
func (*binaryClassGlFinishFenceNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFinishFenceNV(e, obj.(*GlFinishFenceNV))
}
func (*binaryClassGlFinishFenceNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFinishFenceNV{}
	return obj, doDecodeGlFinishFenceNV(d, obj)
}
func (*binaryClassGlFinishFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFinishFenceNV(d, obj.(*GlFinishFenceNV))
}
func (*binaryClassGlFinishFenceNV) Skip(d binary.Decoder) error { return doSkipGlFinishFenceNV(d) }
func (*binaryClassGlFinishFenceNV) Schema() *schema.Class       { return schemaGlFinishFenceNV }

var schemaGlFinishFenceNV = &schema.Class{
	TypeID:  binaryIDGlFinishFenceNV,
	Package: "gles",
	Name:    "GlFinishFenceNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlFlush struct{}

func (*GlFlush) Class() binary.Class {
	return (*binaryClassGlFlush)(nil)
}
func doEncodeGlFlush(e binary.Encoder, o *GlFlush) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFlush(d binary.Decoder, o *GlFlush) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlFlush(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFlush) ID() binary.ID      { return binaryIDGlFlush }
func (*binaryClassGlFlush) New() binary.Object { return &GlFlush{} }
func (*binaryClassGlFlush) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFlush(e, obj.(*GlFlush))
}
func (*binaryClassGlFlush) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFlush{}
	return obj, doDecodeGlFlush(d, obj)
}
func (*binaryClassGlFlush) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFlush(d, obj.(*GlFlush))
}
func (*binaryClassGlFlush) Skip(d binary.Decoder) error { return doSkipGlFlush(d) }
func (*binaryClassGlFlush) Schema() *schema.Class       { return schemaGlFlush }

var schemaGlFlush = &schema.Class{
	TypeID:  binaryIDGlFlush,
	Package: "gles",
	Name:    "GlFlush",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlFlushMappedBufferRange struct{}

func (*GlFlushMappedBufferRange) Class() binary.Class {
	return (*binaryClassGlFlushMappedBufferRange)(nil)
}
func doEncodeGlFlushMappedBufferRange(e binary.Encoder, o *GlFlushMappedBufferRange) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFlushMappedBufferRange(d binary.Decoder, o *GlFlushMappedBufferRange) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlFlushMappedBufferRange(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFlushMappedBufferRange) ID() binary.ID      { return binaryIDGlFlushMappedBufferRange }
func (*binaryClassGlFlushMappedBufferRange) New() binary.Object { return &GlFlushMappedBufferRange{} }
func (*binaryClassGlFlushMappedBufferRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFlushMappedBufferRange(e, obj.(*GlFlushMappedBufferRange))
}
func (*binaryClassGlFlushMappedBufferRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFlushMappedBufferRange{}
	return obj, doDecodeGlFlushMappedBufferRange(d, obj)
}
func (*binaryClassGlFlushMappedBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFlushMappedBufferRange(d, obj.(*GlFlushMappedBufferRange))
}
func (*binaryClassGlFlushMappedBufferRange) Skip(d binary.Decoder) error {
	return doSkipGlFlushMappedBufferRange(d)
}
func (*binaryClassGlFlushMappedBufferRange) Schema() *schema.Class {
	return schemaGlFlushMappedBufferRange
}

var schemaGlFlushMappedBufferRange = &schema.Class{
	TypeID:  binaryIDGlFlushMappedBufferRange,
	Package: "gles",
	Name:    "GlFlushMappedBufferRange",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlFlushMappedBufferRangeEXT struct{}

func (*GlFlushMappedBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlFlushMappedBufferRangeEXT)(nil)
}
func doEncodeGlFlushMappedBufferRangeEXT(e binary.Encoder, o *GlFlushMappedBufferRangeEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFlushMappedBufferRangeEXT(d binary.Decoder, o *GlFlushMappedBufferRangeEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlFlushMappedBufferRangeEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFlushMappedBufferRangeEXT) ID() binary.ID {
	return binaryIDGlFlushMappedBufferRangeEXT
}
func (*binaryClassGlFlushMappedBufferRangeEXT) New() binary.Object {
	return &GlFlushMappedBufferRangeEXT{}
}
func (*binaryClassGlFlushMappedBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFlushMappedBufferRangeEXT(e, obj.(*GlFlushMappedBufferRangeEXT))
}
func (*binaryClassGlFlushMappedBufferRangeEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFlushMappedBufferRangeEXT{}
	return obj, doDecodeGlFlushMappedBufferRangeEXT(d, obj)
}
func (*binaryClassGlFlushMappedBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFlushMappedBufferRangeEXT(d, obj.(*GlFlushMappedBufferRangeEXT))
}
func (*binaryClassGlFlushMappedBufferRangeEXT) Skip(d binary.Decoder) error {
	return doSkipGlFlushMappedBufferRangeEXT(d)
}
func (*binaryClassGlFlushMappedBufferRangeEXT) Schema() *schema.Class {
	return schemaGlFlushMappedBufferRangeEXT
}

var schemaGlFlushMappedBufferRangeEXT = &schema.Class{
	TypeID:  binaryIDGlFlushMappedBufferRangeEXT,
	Package: "gles",
	Name:    "GlFlushMappedBufferRangeEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlFragmentCoverageColorNV struct{}

func (*GlFragmentCoverageColorNV) Class() binary.Class {
	return (*binaryClassGlFragmentCoverageColorNV)(nil)
}
func doEncodeGlFragmentCoverageColorNV(e binary.Encoder, o *GlFragmentCoverageColorNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Color)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFragmentCoverageColorNV(d binary.Decoder, o *GlFragmentCoverageColorNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Color = GLuint(obj)
	}
	return nil
}
func doSkipGlFragmentCoverageColorNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFragmentCoverageColorNV) ID() binary.ID      { return binaryIDGlFragmentCoverageColorNV }
func (*binaryClassGlFragmentCoverageColorNV) New() binary.Object { return &GlFragmentCoverageColorNV{} }
func (*binaryClassGlFragmentCoverageColorNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFragmentCoverageColorNV(e, obj.(*GlFragmentCoverageColorNV))
}
func (*binaryClassGlFragmentCoverageColorNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFragmentCoverageColorNV{}
	return obj, doDecodeGlFragmentCoverageColorNV(d, obj)
}
func (*binaryClassGlFragmentCoverageColorNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFragmentCoverageColorNV(d, obj.(*GlFragmentCoverageColorNV))
}
func (*binaryClassGlFragmentCoverageColorNV) Skip(d binary.Decoder) error {
	return doSkipGlFragmentCoverageColorNV(d)
}
func (*binaryClassGlFragmentCoverageColorNV) Schema() *schema.Class {
	return schemaGlFragmentCoverageColorNV
}

var schemaGlFragmentCoverageColorNV = &schema.Class{
	TypeID:  binaryIDGlFragmentCoverageColorNV,
	Package: "gles",
	Name:    "GlFragmentCoverageColorNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Color", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlFramebufferParameteri struct{}

func (*GlFramebufferParameteri) Class() binary.Class {
	return (*binaryClassGlFramebufferParameteri)(nil)
}
func doEncodeGlFramebufferParameteri(e binary.Encoder, o *GlFramebufferParameteri) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Param)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferParameteri(d binary.Decoder, o *GlFramebufferParameteri) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Param = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferParameteri(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferParameteri) ID() binary.ID      { return binaryIDGlFramebufferParameteri }
func (*binaryClassGlFramebufferParameteri) New() binary.Object { return &GlFramebufferParameteri{} }
func (*binaryClassGlFramebufferParameteri) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferParameteri(e, obj.(*GlFramebufferParameteri))
}
func (*binaryClassGlFramebufferParameteri) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferParameteri{}
	return obj, doDecodeGlFramebufferParameteri(d, obj)
}
func (*binaryClassGlFramebufferParameteri) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferParameteri(d, obj.(*GlFramebufferParameteri))
}
func (*binaryClassGlFramebufferParameteri) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferParameteri(d)
}
func (*binaryClassGlFramebufferParameteri) Schema() *schema.Class {
	return schemaGlFramebufferParameteri
}

var schemaGlFramebufferParameteri = &schema.Class{
	TypeID:  binaryIDGlFramebufferParameteri,
	Package: "gles",
	Name:    "GlFramebufferParameteri",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferRenderbuffer struct{}

func (*GlFramebufferRenderbuffer) Class() binary.Class {
	return (*binaryClassGlFramebufferRenderbuffer)(nil)
}
func doEncodeGlFramebufferRenderbuffer(e binary.Encoder, o *GlFramebufferRenderbuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FramebufferAttachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.RenderbufferTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferRenderbuffer(d binary.Decoder, o *GlFramebufferRenderbuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferAttachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.RenderbufferTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Renderbuffer = RenderbufferId(obj)
	}
	return nil
}
func doSkipGlFramebufferRenderbuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferRenderbuffer) ID() binary.ID      { return binaryIDGlFramebufferRenderbuffer }
func (*binaryClassGlFramebufferRenderbuffer) New() binary.Object { return &GlFramebufferRenderbuffer{} }
func (*binaryClassGlFramebufferRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferRenderbuffer(e, obj.(*GlFramebufferRenderbuffer))
}
func (*binaryClassGlFramebufferRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferRenderbuffer{}
	return obj, doDecodeGlFramebufferRenderbuffer(d, obj)
}
func (*binaryClassGlFramebufferRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferRenderbuffer(d, obj.(*GlFramebufferRenderbuffer))
}
func (*binaryClassGlFramebufferRenderbuffer) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferRenderbuffer(d)
}
func (*binaryClassGlFramebufferRenderbuffer) Schema() *schema.Class {
	return schemaGlFramebufferRenderbuffer
}

var schemaGlFramebufferRenderbuffer = &schema.Class{
	TypeID:  binaryIDGlFramebufferRenderbuffer,
	Package: "gles",
	Name:    "GlFramebufferRenderbuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FramebufferAttachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "RenderbufferTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlFramebufferSampleLocationsfvNV struct{}

func (*GlFramebufferSampleLocationsfvNV) Class() binary.Class {
	return (*binaryClassGlFramebufferSampleLocationsfvNV)(nil)
}
func doEncodeGlFramebufferSampleLocationsfvNV(e binary.Encoder, o *GlFramebufferSampleLocationsfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Start)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlFramebufferSampleLocationsfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Start = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlFramebufferSampleLocationsfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) ID() binary.ID {
	return binaryIDGlFramebufferSampleLocationsfvNV
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) New() binary.Object {
	return &GlFramebufferSampleLocationsfvNV{}
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferSampleLocationsfvNV(e, obj.(*GlFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferSampleLocationsfvNV{}
	return obj, doDecodeGlFramebufferSampleLocationsfvNV(d, obj)
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferSampleLocationsfvNV(d, obj.(*GlFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferSampleLocationsfvNV(d)
}
func (*binaryClassGlFramebufferSampleLocationsfvNV) Schema() *schema.Class {
	return schemaGlFramebufferSampleLocationsfvNV
}

var schemaGlFramebufferSampleLocationsfvNV = &schema.Class{
	TypeID:  binaryIDGlFramebufferSampleLocationsfvNV,
	Package: "gles",
	Name:    "GlFramebufferSampleLocationsfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlFramebufferTexture2D struct{}

func (*GlFramebufferTexture2D) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2D)(nil)
}
func doEncodeGlFramebufferTexture2D(e binary.Encoder, o *GlFramebufferTexture2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FramebufferAttachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TextureTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTexture2D(d binary.Decoder, o *GlFramebufferTexture2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferAttachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TextureTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferTexture2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTexture2D) ID() binary.ID      { return binaryIDGlFramebufferTexture2D }
func (*binaryClassGlFramebufferTexture2D) New() binary.Object { return &GlFramebufferTexture2D{} }
func (*binaryClassGlFramebufferTexture2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTexture2D(e, obj.(*GlFramebufferTexture2D))
}
func (*binaryClassGlFramebufferTexture2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTexture2D{}
	return obj, doDecodeGlFramebufferTexture2D(d, obj)
}
func (*binaryClassGlFramebufferTexture2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTexture2D(d, obj.(*GlFramebufferTexture2D))
}
func (*binaryClassGlFramebufferTexture2D) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTexture2D(d)
}
func (*binaryClassGlFramebufferTexture2D) Schema() *schema.Class { return schemaGlFramebufferTexture2D }

var schemaGlFramebufferTexture2D = &schema.Class{
	TypeID:  binaryIDGlFramebufferTexture2D,
	Package: "gles",
	Name:    "GlFramebufferTexture2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FramebufferAttachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TextureTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTexture2DMultisampleEXT struct{}

func (*GlFramebufferTexture2DMultisampleEXT) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2DMultisampleEXT)(nil)
}
func doEncodeGlFramebufferTexture2DMultisampleEXT(e binary.Encoder, o *GlFramebufferTexture2DMultisampleEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Textarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTexture2DMultisampleEXT(d binary.Decoder, o *GlFramebufferTexture2DMultisampleEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Textarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	return nil
}
func doSkipGlFramebufferTexture2DMultisampleEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) ID() binary.ID {
	return binaryIDGlFramebufferTexture2DMultisampleEXT
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) New() binary.Object {
	return &GlFramebufferTexture2DMultisampleEXT{}
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTexture2DMultisampleEXT(e, obj.(*GlFramebufferTexture2DMultisampleEXT))
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTexture2DMultisampleEXT{}
	return obj, doDecodeGlFramebufferTexture2DMultisampleEXT(d, obj)
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTexture2DMultisampleEXT(d, obj.(*GlFramebufferTexture2DMultisampleEXT))
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTexture2DMultisampleEXT(d)
}
func (*binaryClassGlFramebufferTexture2DMultisampleEXT) Schema() *schema.Class {
	return schemaGlFramebufferTexture2DMultisampleEXT
}

var schemaGlFramebufferTexture2DMultisampleEXT = &schema.Class{
	TypeID:  binaryIDGlFramebufferTexture2DMultisampleEXT,
	Package: "gles",
	Name:    "GlFramebufferTexture2DMultisampleEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Textarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTexture2DMultisampleIMG struct{}

func (*GlFramebufferTexture2DMultisampleIMG) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture2DMultisampleIMG)(nil)
}
func doEncodeGlFramebufferTexture2DMultisampleIMG(e binary.Encoder, o *GlFramebufferTexture2DMultisampleIMG) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Textarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTexture2DMultisampleIMG(d binary.Decoder, o *GlFramebufferTexture2DMultisampleIMG) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Textarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	return nil
}
func doSkipGlFramebufferTexture2DMultisampleIMG(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) ID() binary.ID {
	return binaryIDGlFramebufferTexture2DMultisampleIMG
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) New() binary.Object {
	return &GlFramebufferTexture2DMultisampleIMG{}
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTexture2DMultisampleIMG(e, obj.(*GlFramebufferTexture2DMultisampleIMG))
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTexture2DMultisampleIMG{}
	return obj, doDecodeGlFramebufferTexture2DMultisampleIMG(d, obj)
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTexture2DMultisampleIMG(d, obj.(*GlFramebufferTexture2DMultisampleIMG))
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTexture2DMultisampleIMG(d)
}
func (*binaryClassGlFramebufferTexture2DMultisampleIMG) Schema() *schema.Class {
	return schemaGlFramebufferTexture2DMultisampleIMG
}

var schemaGlFramebufferTexture2DMultisampleIMG = &schema.Class{
	TypeID:  binaryIDGlFramebufferTexture2DMultisampleIMG,
	Package: "gles",
	Name:    "GlFramebufferTexture2DMultisampleIMG",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Textarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTexture3DOES struct{}

func (*GlFramebufferTexture3DOES) Class() binary.Class {
	return (*binaryClassGlFramebufferTexture3DOES)(nil)
}
func doEncodeGlFramebufferTexture3DOES(e binary.Encoder, o *GlFramebufferTexture3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Textarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTexture3DOES(d binary.Decoder, o *GlFramebufferTexture3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Textarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferTexture3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTexture3DOES) ID() binary.ID      { return binaryIDGlFramebufferTexture3DOES }
func (*binaryClassGlFramebufferTexture3DOES) New() binary.Object { return &GlFramebufferTexture3DOES{} }
func (*binaryClassGlFramebufferTexture3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTexture3DOES(e, obj.(*GlFramebufferTexture3DOES))
}
func (*binaryClassGlFramebufferTexture3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTexture3DOES{}
	return obj, doDecodeGlFramebufferTexture3DOES(d, obj)
}
func (*binaryClassGlFramebufferTexture3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTexture3DOES(d, obj.(*GlFramebufferTexture3DOES))
}
func (*binaryClassGlFramebufferTexture3DOES) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTexture3DOES(d)
}
func (*binaryClassGlFramebufferTexture3DOES) Schema() *schema.Class {
	return schemaGlFramebufferTexture3DOES
}

var schemaGlFramebufferTexture3DOES = &schema.Class{
	TypeID:  binaryIDGlFramebufferTexture3DOES,
	Package: "gles",
	Name:    "GlFramebufferTexture3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Textarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTextureEXT struct{}

func (*GlFramebufferTextureEXT) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureEXT)(nil)
}
func doEncodeGlFramebufferTextureEXT(e binary.Encoder, o *GlFramebufferTextureEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTextureEXT(d binary.Decoder, o *GlFramebufferTextureEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferTextureEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTextureEXT) ID() binary.ID      { return binaryIDGlFramebufferTextureEXT }
func (*binaryClassGlFramebufferTextureEXT) New() binary.Object { return &GlFramebufferTextureEXT{} }
func (*binaryClassGlFramebufferTextureEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTextureEXT(e, obj.(*GlFramebufferTextureEXT))
}
func (*binaryClassGlFramebufferTextureEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTextureEXT{}
	return obj, doDecodeGlFramebufferTextureEXT(d, obj)
}
func (*binaryClassGlFramebufferTextureEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTextureEXT(d, obj.(*GlFramebufferTextureEXT))
}
func (*binaryClassGlFramebufferTextureEXT) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTextureEXT(d)
}
func (*binaryClassGlFramebufferTextureEXT) Schema() *schema.Class {
	return schemaGlFramebufferTextureEXT
}

var schemaGlFramebufferTextureEXT = &schema.Class{
	TypeID:  binaryIDGlFramebufferTextureEXT,
	Package: "gles",
	Name:    "GlFramebufferTextureEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTextureLayer struct{}

func (*GlFramebufferTextureLayer) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureLayer)(nil)
}
func doEncodeGlFramebufferTextureLayer(e binary.Encoder, o *GlFramebufferTextureLayer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Layer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTextureLayer(d binary.Decoder, o *GlFramebufferTextureLayer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Layer = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferTextureLayer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTextureLayer) ID() binary.ID      { return binaryIDGlFramebufferTextureLayer }
func (*binaryClassGlFramebufferTextureLayer) New() binary.Object { return &GlFramebufferTextureLayer{} }
func (*binaryClassGlFramebufferTextureLayer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTextureLayer(e, obj.(*GlFramebufferTextureLayer))
}
func (*binaryClassGlFramebufferTextureLayer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTextureLayer{}
	return obj, doDecodeGlFramebufferTextureLayer(d, obj)
}
func (*binaryClassGlFramebufferTextureLayer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTextureLayer(d, obj.(*GlFramebufferTextureLayer))
}
func (*binaryClassGlFramebufferTextureLayer) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTextureLayer(d)
}
func (*binaryClassGlFramebufferTextureLayer) Schema() *schema.Class {
	return schemaGlFramebufferTextureLayer
}

var schemaGlFramebufferTextureLayer = &schema.Class{
	TypeID:  binaryIDGlFramebufferTextureLayer,
	Package: "gles",
	Name:    "GlFramebufferTextureLayer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Layer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTextureMultiviewOVR struct{}

func (*GlFramebufferTextureMultiviewOVR) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureMultiviewOVR)(nil)
}
func doEncodeGlFramebufferTextureMultiviewOVR(e binary.Encoder, o *GlFramebufferTextureMultiviewOVR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BaseViewIndex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumViews)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTextureMultiviewOVR(d binary.Decoder, o *GlFramebufferTextureMultiviewOVR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BaseViewIndex = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumViews = GLsizei(obj)
	}
	return nil
}
func doSkipGlFramebufferTextureMultiviewOVR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) ID() binary.ID {
	return binaryIDGlFramebufferTextureMultiviewOVR
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) New() binary.Object {
	return &GlFramebufferTextureMultiviewOVR{}
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTextureMultiviewOVR(e, obj.(*GlFramebufferTextureMultiviewOVR))
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTextureMultiviewOVR{}
	return obj, doDecodeGlFramebufferTextureMultiviewOVR(d, obj)
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTextureMultiviewOVR(d, obj.(*GlFramebufferTextureMultiviewOVR))
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTextureMultiviewOVR(d)
}
func (*binaryClassGlFramebufferTextureMultiviewOVR) Schema() *schema.Class {
	return schemaGlFramebufferTextureMultiviewOVR
}

var schemaGlFramebufferTextureMultiviewOVR = &schema.Class{
	TypeID:  binaryIDGlFramebufferTextureMultiviewOVR,
	Package: "gles",
	Name:    "GlFramebufferTextureMultiviewOVR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "BaseViewIndex", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "NumViews", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlFramebufferTextureOES struct{}

func (*GlFramebufferTextureOES) Class() binary.Class {
	return (*binaryClassGlFramebufferTextureOES)(nil)
}
func doEncodeGlFramebufferTextureOES(e binary.Encoder, o *GlFramebufferTextureOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFramebufferTextureOES(d binary.Decoder, o *GlFramebufferTextureOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	return nil
}
func doSkipGlFramebufferTextureOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFramebufferTextureOES) ID() binary.ID      { return binaryIDGlFramebufferTextureOES }
func (*binaryClassGlFramebufferTextureOES) New() binary.Object { return &GlFramebufferTextureOES{} }
func (*binaryClassGlFramebufferTextureOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFramebufferTextureOES(e, obj.(*GlFramebufferTextureOES))
}
func (*binaryClassGlFramebufferTextureOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFramebufferTextureOES{}
	return obj, doDecodeGlFramebufferTextureOES(d, obj)
}
func (*binaryClassGlFramebufferTextureOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFramebufferTextureOES(d, obj.(*GlFramebufferTextureOES))
}
func (*binaryClassGlFramebufferTextureOES) Skip(d binary.Decoder) error {
	return doSkipGlFramebufferTextureOES(d)
}
func (*binaryClassGlFramebufferTextureOES) Schema() *schema.Class {
	return schemaGlFramebufferTextureOES
}

var schemaGlFramebufferTextureOES = &schema.Class{
	TypeID:  binaryIDGlFramebufferTextureOES,
	Package: "gles",
	Name:    "GlFramebufferTextureOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlFrontFace struct{}

func (*GlFrontFace) Class() binary.Class {
	return (*binaryClassGlFrontFace)(nil)
}
func doEncodeGlFrontFace(e binary.Encoder, o *GlFrontFace) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Orientation)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlFrontFace(d binary.Decoder, o *GlFrontFace) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Orientation = GLenum(obj)
	}
	return nil
}
func doSkipGlFrontFace(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlFrontFace) ID() binary.ID      { return binaryIDGlFrontFace }
func (*binaryClassGlFrontFace) New() binary.Object { return &GlFrontFace{} }
func (*binaryClassGlFrontFace) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlFrontFace(e, obj.(*GlFrontFace))
}
func (*binaryClassGlFrontFace) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlFrontFace{}
	return obj, doDecodeGlFrontFace(d, obj)
}
func (*binaryClassGlFrontFace) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlFrontFace(d, obj.(*GlFrontFace))
}
func (*binaryClassGlFrontFace) Skip(d binary.Decoder) error { return doSkipGlFrontFace(d) }
func (*binaryClassGlFrontFace) Schema() *schema.Class       { return schemaGlFrontFace }

var schemaGlFrontFace = &schema.Class{
	TypeID:  binaryIDGlFrontFace,
	Package: "gles",
	Name:    "GlFrontFace",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Orientation", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlGenBuffers struct{}

func (*GlGenBuffers) Class() binary.Class {
	return (*binaryClassGlGenBuffers)(nil)
}
func doEncodeGlGenBuffers(e binary.Encoder, o *GlGenBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Buffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenBuffers(d binary.Decoder, o *GlGenBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Buffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BufferIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenBuffers) ID() binary.ID      { return binaryIDGlGenBuffers }
func (*binaryClassGlGenBuffers) New() binary.Object { return &GlGenBuffers{} }
func (*binaryClassGlGenBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenBuffers(e, obj.(*GlGenBuffers))
}
func (*binaryClassGlGenBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenBuffers{}
	return obj, doDecodeGlGenBuffers(d, obj)
}
func (*binaryClassGlGenBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenBuffers(d, obj.(*GlGenBuffers))
}
func (*binaryClassGlGenBuffers) Skip(d binary.Decoder) error { return doSkipGlGenBuffers(d) }
func (*binaryClassGlGenBuffers) Schema() *schema.Class       { return schemaGlGenBuffers }

var schemaGlGenBuffers = &schema.Class{
	TypeID:  binaryIDGlGenBuffers,
	Package: "gles",
	Name:    "GlGenBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Buffers", Type: &schema.Struct{Name: "BufferIdᵖ", ID: (*BufferIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenFencesNV struct{}

func (*GlGenFencesNV) Class() binary.Class {
	return (*binaryClassGlGenFencesNV)(nil)
}
func doEncodeGlGenFencesNV(e binary.Encoder, o *GlGenFencesNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Fences); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenFencesNV(d binary.Decoder, o *GlGenFencesNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Fences); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenFencesNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenFencesNV) ID() binary.ID      { return binaryIDGlGenFencesNV }
func (*binaryClassGlGenFencesNV) New() binary.Object { return &GlGenFencesNV{} }
func (*binaryClassGlGenFencesNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenFencesNV(e, obj.(*GlGenFencesNV))
}
func (*binaryClassGlGenFencesNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenFencesNV{}
	return obj, doDecodeGlGenFencesNV(d, obj)
}
func (*binaryClassGlGenFencesNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenFencesNV(d, obj.(*GlGenFencesNV))
}
func (*binaryClassGlGenFencesNV) Skip(d binary.Decoder) error { return doSkipGlGenFencesNV(d) }
func (*binaryClassGlGenFencesNV) Schema() *schema.Class       { return schemaGlGenFencesNV }

var schemaGlGenFencesNV = &schema.Class{
	TypeID:  binaryIDGlGenFencesNV,
	Package: "gles",
	Name:    "GlGenFencesNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Fences", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenFramebuffers struct{}

func (*GlGenFramebuffers) Class() binary.Class {
	return (*binaryClassGlGenFramebuffers)(nil)
}
func doEncodeGlGenFramebuffers(e binary.Encoder, o *GlGenFramebuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Framebuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenFramebuffers(d binary.Decoder, o *GlGenFramebuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Framebuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenFramebuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*FramebufferIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenFramebuffers) ID() binary.ID      { return binaryIDGlGenFramebuffers }
func (*binaryClassGlGenFramebuffers) New() binary.Object { return &GlGenFramebuffers{} }
func (*binaryClassGlGenFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenFramebuffers(e, obj.(*GlGenFramebuffers))
}
func (*binaryClassGlGenFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenFramebuffers{}
	return obj, doDecodeGlGenFramebuffers(d, obj)
}
func (*binaryClassGlGenFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenFramebuffers(d, obj.(*GlGenFramebuffers))
}
func (*binaryClassGlGenFramebuffers) Skip(d binary.Decoder) error { return doSkipGlGenFramebuffers(d) }
func (*binaryClassGlGenFramebuffers) Schema() *schema.Class       { return schemaGlGenFramebuffers }

var schemaGlGenFramebuffers = &schema.Class{
	TypeID:  binaryIDGlGenFramebuffers,
	Package: "gles",
	Name:    "GlGenFramebuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Framebuffers", Type: &schema.Struct{Name: "FramebufferIdᵖ", ID: (*FramebufferIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenPathsNV struct{}

func (*GlGenPathsNV) Class() binary.Class {
	return (*binaryClassGlGenPathsNV)(nil)
}
func doEncodeGlGenPathsNV(e binary.Encoder, o *GlGenPathsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Range)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenPathsNV(d binary.Decoder, o *GlGenPathsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Range = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLuint(obj)
	}
	return nil
}
func doSkipGlGenPathsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenPathsNV) ID() binary.ID      { return binaryIDGlGenPathsNV }
func (*binaryClassGlGenPathsNV) New() binary.Object { return &GlGenPathsNV{} }
func (*binaryClassGlGenPathsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenPathsNV(e, obj.(*GlGenPathsNV))
}
func (*binaryClassGlGenPathsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenPathsNV{}
	return obj, doDecodeGlGenPathsNV(d, obj)
}
func (*binaryClassGlGenPathsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenPathsNV(d, obj.(*GlGenPathsNV))
}
func (*binaryClassGlGenPathsNV) Skip(d binary.Decoder) error { return doSkipGlGenPathsNV(d) }
func (*binaryClassGlGenPathsNV) Schema() *schema.Class       { return schemaGlGenPathsNV }

var schemaGlGenPathsNV = &schema.Class{
	TypeID:  binaryIDGlGenPathsNV,
	Package: "gles",
	Name:    "GlGenPathsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Range", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlGenPerfMonitorsAMD struct{}

func (*GlGenPerfMonitorsAMD) Class() binary.Class {
	return (*binaryClassGlGenPerfMonitorsAMD)(nil)
}
func doEncodeGlGenPerfMonitorsAMD(e binary.Encoder, o *GlGenPerfMonitorsAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Monitors); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenPerfMonitorsAMD(d binary.Decoder, o *GlGenPerfMonitorsAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Monitors); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenPerfMonitorsAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenPerfMonitorsAMD) ID() binary.ID      { return binaryIDGlGenPerfMonitorsAMD }
func (*binaryClassGlGenPerfMonitorsAMD) New() binary.Object { return &GlGenPerfMonitorsAMD{} }
func (*binaryClassGlGenPerfMonitorsAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenPerfMonitorsAMD(e, obj.(*GlGenPerfMonitorsAMD))
}
func (*binaryClassGlGenPerfMonitorsAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenPerfMonitorsAMD{}
	return obj, doDecodeGlGenPerfMonitorsAMD(d, obj)
}
func (*binaryClassGlGenPerfMonitorsAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenPerfMonitorsAMD(d, obj.(*GlGenPerfMonitorsAMD))
}
func (*binaryClassGlGenPerfMonitorsAMD) Skip(d binary.Decoder) error {
	return doSkipGlGenPerfMonitorsAMD(d)
}
func (*binaryClassGlGenPerfMonitorsAMD) Schema() *schema.Class { return schemaGlGenPerfMonitorsAMD }

var schemaGlGenPerfMonitorsAMD = &schema.Class{
	TypeID:  binaryIDGlGenPerfMonitorsAMD,
	Package: "gles",
	Name:    "GlGenPerfMonitorsAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Monitors", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassPipelineIdᵖ struct{}

func (*PipelineIdᵖ) Class() binary.Class {
	return (*binaryClassPipelineIdᵖ)(nil)
}
func doEncodePipelineIdᵖ(e binary.Encoder, o *PipelineIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodePipelineIdᵖ(d binary.Decoder, o *PipelineIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipPipelineIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassPipelineIdᵖ) ID() binary.ID      { return binaryIDPipelineIdᵖ }
func (*binaryClassPipelineIdᵖ) New() binary.Object { return &PipelineIdᵖ{} }
func (*binaryClassPipelineIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodePipelineIdᵖ(e, obj.(*PipelineIdᵖ))
}
func (*binaryClassPipelineIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &PipelineIdᵖ{}
	return obj, doDecodePipelineIdᵖ(d, obj)
}
func (*binaryClassPipelineIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodePipelineIdᵖ(d, obj.(*PipelineIdᵖ))
}
func (*binaryClassPipelineIdᵖ) Skip(d binary.Decoder) error { return doSkipPipelineIdᵖ(d) }
func (*binaryClassPipelineIdᵖ) Schema() *schema.Class       { return schemaPipelineIdᵖ }

var schemaPipelineIdᵖ = &schema.Class{
	TypeID:  binaryIDPipelineIdᵖ,
	Package: "gles",
	Name:    "PipelineIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGenProgramPipelines struct{}

func (*GlGenProgramPipelines) Class() binary.Class {
	return (*binaryClassGlGenProgramPipelines)(nil)
}
func doEncodeGlGenProgramPipelines(e binary.Encoder, o *GlGenProgramPipelines) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenProgramPipelines(d binary.Decoder, o *GlGenProgramPipelines) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenProgramPipelines(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*PipelineIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenProgramPipelines) ID() binary.ID      { return binaryIDGlGenProgramPipelines }
func (*binaryClassGlGenProgramPipelines) New() binary.Object { return &GlGenProgramPipelines{} }
func (*binaryClassGlGenProgramPipelines) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenProgramPipelines(e, obj.(*GlGenProgramPipelines))
}
func (*binaryClassGlGenProgramPipelines) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenProgramPipelines{}
	return obj, doDecodeGlGenProgramPipelines(d, obj)
}
func (*binaryClassGlGenProgramPipelines) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenProgramPipelines(d, obj.(*GlGenProgramPipelines))
}
func (*binaryClassGlGenProgramPipelines) Skip(d binary.Decoder) error {
	return doSkipGlGenProgramPipelines(d)
}
func (*binaryClassGlGenProgramPipelines) Schema() *schema.Class { return schemaGlGenProgramPipelines }

var schemaGlGenProgramPipelines = &schema.Class{
	TypeID:  binaryIDGlGenProgramPipelines,
	Package: "gles",
	Name:    "GlGenProgramPipelines",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pipelines", Type: &schema.Struct{Name: "PipelineIdᵖ", ID: (*PipelineIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenProgramPipelinesEXT struct{}

func (*GlGenProgramPipelinesEXT) Class() binary.Class {
	return (*binaryClassGlGenProgramPipelinesEXT)(nil)
}
func doEncodeGlGenProgramPipelinesEXT(e binary.Encoder, o *GlGenProgramPipelinesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenProgramPipelinesEXT(d binary.Decoder, o *GlGenProgramPipelinesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Pipelines); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenProgramPipelinesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*PipelineIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenProgramPipelinesEXT) ID() binary.ID      { return binaryIDGlGenProgramPipelinesEXT }
func (*binaryClassGlGenProgramPipelinesEXT) New() binary.Object { return &GlGenProgramPipelinesEXT{} }
func (*binaryClassGlGenProgramPipelinesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenProgramPipelinesEXT(e, obj.(*GlGenProgramPipelinesEXT))
}
func (*binaryClassGlGenProgramPipelinesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenProgramPipelinesEXT{}
	return obj, doDecodeGlGenProgramPipelinesEXT(d, obj)
}
func (*binaryClassGlGenProgramPipelinesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenProgramPipelinesEXT(d, obj.(*GlGenProgramPipelinesEXT))
}
func (*binaryClassGlGenProgramPipelinesEXT) Skip(d binary.Decoder) error {
	return doSkipGlGenProgramPipelinesEXT(d)
}
func (*binaryClassGlGenProgramPipelinesEXT) Schema() *schema.Class {
	return schemaGlGenProgramPipelinesEXT
}

var schemaGlGenProgramPipelinesEXT = &schema.Class{
	TypeID:  binaryIDGlGenProgramPipelinesEXT,
	Package: "gles",
	Name:    "GlGenProgramPipelinesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pipelines", Type: &schema.Struct{Name: "PipelineIdᵖ", ID: (*PipelineIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassQueryIdᵖ struct{}

func (*QueryIdᵖ) Class() binary.Class {
	return (*binaryClassQueryIdᵖ)(nil)
}
func doEncodeQueryIdᵖ(e binary.Encoder, o *QueryIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeQueryIdᵖ(d binary.Decoder, o *QueryIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipQueryIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassQueryIdᵖ) ID() binary.ID      { return binaryIDQueryIdᵖ }
func (*binaryClassQueryIdᵖ) New() binary.Object { return &QueryIdᵖ{} }
func (*binaryClassQueryIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeQueryIdᵖ(e, obj.(*QueryIdᵖ))
}
func (*binaryClassQueryIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &QueryIdᵖ{}
	return obj, doDecodeQueryIdᵖ(d, obj)
}
func (*binaryClassQueryIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeQueryIdᵖ(d, obj.(*QueryIdᵖ))
}
func (*binaryClassQueryIdᵖ) Skip(d binary.Decoder) error { return doSkipQueryIdᵖ(d) }
func (*binaryClassQueryIdᵖ) Schema() *schema.Class       { return schemaQueryIdᵖ }

var schemaQueryIdᵖ = &schema.Class{
	TypeID:  binaryIDQueryIdᵖ,
	Package: "gles",
	Name:    "QueryIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGenQueries struct{}

func (*GlGenQueries) Class() binary.Class {
	return (*binaryClassGlGenQueries)(nil)
}
func doEncodeGlGenQueries(e binary.Encoder, o *GlGenQueries) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenQueries(d binary.Decoder, o *GlGenQueries) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenQueries(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenQueries) ID() binary.ID      { return binaryIDGlGenQueries }
func (*binaryClassGlGenQueries) New() binary.Object { return &GlGenQueries{} }
func (*binaryClassGlGenQueries) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenQueries(e, obj.(*GlGenQueries))
}
func (*binaryClassGlGenQueries) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenQueries{}
	return obj, doDecodeGlGenQueries(d, obj)
}
func (*binaryClassGlGenQueries) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenQueries(d, obj.(*GlGenQueries))
}
func (*binaryClassGlGenQueries) Skip(d binary.Decoder) error { return doSkipGlGenQueries(d) }
func (*binaryClassGlGenQueries) Schema() *schema.Class       { return schemaGlGenQueries }

var schemaGlGenQueries = &schema.Class{
	TypeID:  binaryIDGlGenQueries,
	Package: "gles",
	Name:    "GlGenQueries",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ", ID: (*QueryIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenQueriesEXT struct{}

func (*GlGenQueriesEXT) Class() binary.Class {
	return (*binaryClassGlGenQueriesEXT)(nil)
}
func doEncodeGlGenQueriesEXT(e binary.Encoder, o *GlGenQueriesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenQueriesEXT(d binary.Decoder, o *GlGenQueriesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Queries); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenQueriesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*QueryIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenQueriesEXT) ID() binary.ID      { return binaryIDGlGenQueriesEXT }
func (*binaryClassGlGenQueriesEXT) New() binary.Object { return &GlGenQueriesEXT{} }
func (*binaryClassGlGenQueriesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenQueriesEXT(e, obj.(*GlGenQueriesEXT))
}
func (*binaryClassGlGenQueriesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenQueriesEXT{}
	return obj, doDecodeGlGenQueriesEXT(d, obj)
}
func (*binaryClassGlGenQueriesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenQueriesEXT(d, obj.(*GlGenQueriesEXT))
}
func (*binaryClassGlGenQueriesEXT) Skip(d binary.Decoder) error { return doSkipGlGenQueriesEXT(d) }
func (*binaryClassGlGenQueriesEXT) Schema() *schema.Class       { return schemaGlGenQueriesEXT }

var schemaGlGenQueriesEXT = &schema.Class{
	TypeID:  binaryIDGlGenQueriesEXT,
	Package: "gles",
	Name:    "GlGenQueriesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Queries", Type: &schema.Struct{Name: "QueryIdᵖ", ID: (*QueryIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenRenderbuffers struct{}

func (*GlGenRenderbuffers) Class() binary.Class {
	return (*binaryClassGlGenRenderbuffers)(nil)
}
func doEncodeGlGenRenderbuffers(e binary.Encoder, o *GlGenRenderbuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Renderbuffers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenRenderbuffers(d binary.Decoder, o *GlGenRenderbuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Renderbuffers); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenRenderbuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*RenderbufferIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenRenderbuffers) ID() binary.ID      { return binaryIDGlGenRenderbuffers }
func (*binaryClassGlGenRenderbuffers) New() binary.Object { return &GlGenRenderbuffers{} }
func (*binaryClassGlGenRenderbuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenRenderbuffers(e, obj.(*GlGenRenderbuffers))
}
func (*binaryClassGlGenRenderbuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenRenderbuffers{}
	return obj, doDecodeGlGenRenderbuffers(d, obj)
}
func (*binaryClassGlGenRenderbuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenRenderbuffers(d, obj.(*GlGenRenderbuffers))
}
func (*binaryClassGlGenRenderbuffers) Skip(d binary.Decoder) error { return doSkipGlGenRenderbuffers(d) }
func (*binaryClassGlGenRenderbuffers) Schema() *schema.Class       { return schemaGlGenRenderbuffers }

var schemaGlGenRenderbuffers = &schema.Class{
	TypeID:  binaryIDGlGenRenderbuffers,
	Package: "gles",
	Name:    "GlGenRenderbuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Renderbuffers", Type: &schema.Struct{Name: "RenderbufferIdᵖ", ID: (*RenderbufferIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassSamplerIdᵖ struct{}

func (*SamplerIdᵖ) Class() binary.Class {
	return (*binaryClassSamplerIdᵖ)(nil)
}
func doEncodeSamplerIdᵖ(e binary.Encoder, o *SamplerIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeSamplerIdᵖ(d binary.Decoder, o *SamplerIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipSamplerIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSamplerIdᵖ) ID() binary.ID      { return binaryIDSamplerIdᵖ }
func (*binaryClassSamplerIdᵖ) New() binary.Object { return &SamplerIdᵖ{} }
func (*binaryClassSamplerIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSamplerIdᵖ(e, obj.(*SamplerIdᵖ))
}
func (*binaryClassSamplerIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SamplerIdᵖ{}
	return obj, doDecodeSamplerIdᵖ(d, obj)
}
func (*binaryClassSamplerIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSamplerIdᵖ(d, obj.(*SamplerIdᵖ))
}
func (*binaryClassSamplerIdᵖ) Skip(d binary.Decoder) error { return doSkipSamplerIdᵖ(d) }
func (*binaryClassSamplerIdᵖ) Schema() *schema.Class       { return schemaSamplerIdᵖ }

var schemaSamplerIdᵖ = &schema.Class{
	TypeID:  binaryIDSamplerIdᵖ,
	Package: "gles",
	Name:    "SamplerIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGenSamplers struct{}

func (*GlGenSamplers) Class() binary.Class {
	return (*binaryClassGlGenSamplers)(nil)
}
func doEncodeGlGenSamplers(e binary.Encoder, o *GlGenSamplers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Samplers); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenSamplers(d binary.Decoder, o *GlGenSamplers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Samplers); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenSamplers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*SamplerIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenSamplers) ID() binary.ID      { return binaryIDGlGenSamplers }
func (*binaryClassGlGenSamplers) New() binary.Object { return &GlGenSamplers{} }
func (*binaryClassGlGenSamplers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenSamplers(e, obj.(*GlGenSamplers))
}
func (*binaryClassGlGenSamplers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenSamplers{}
	return obj, doDecodeGlGenSamplers(d, obj)
}
func (*binaryClassGlGenSamplers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenSamplers(d, obj.(*GlGenSamplers))
}
func (*binaryClassGlGenSamplers) Skip(d binary.Decoder) error { return doSkipGlGenSamplers(d) }
func (*binaryClassGlGenSamplers) Schema() *schema.Class       { return schemaGlGenSamplers }

var schemaGlGenSamplers = &schema.Class{
	TypeID:  binaryIDGlGenSamplers,
	Package: "gles",
	Name:    "GlGenSamplers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Samplers", Type: &schema.Struct{Name: "SamplerIdᵖ", ID: (*SamplerIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenTextures struct{}

func (*GlGenTextures) Class() binary.Class {
	return (*binaryClassGlGenTextures)(nil)
}
func doEncodeGlGenTextures(e binary.Encoder, o *GlGenTextures) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Textures); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenTextures(d binary.Decoder, o *GlGenTextures) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Textures); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenTextures(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TextureIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenTextures) ID() binary.ID      { return binaryIDGlGenTextures }
func (*binaryClassGlGenTextures) New() binary.Object { return &GlGenTextures{} }
func (*binaryClassGlGenTextures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenTextures(e, obj.(*GlGenTextures))
}
func (*binaryClassGlGenTextures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenTextures{}
	return obj, doDecodeGlGenTextures(d, obj)
}
func (*binaryClassGlGenTextures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenTextures(d, obj.(*GlGenTextures))
}
func (*binaryClassGlGenTextures) Skip(d binary.Decoder) error { return doSkipGlGenTextures(d) }
func (*binaryClassGlGenTextures) Schema() *schema.Class       { return schemaGlGenTextures }

var schemaGlGenTextures = &schema.Class{
	TypeID:  binaryIDGlGenTextures,
	Package: "gles",
	Name:    "GlGenTextures",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Textures", Type: &schema.Struct{Name: "TextureIdᵖ", ID: (*TextureIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassTransformFeedbackIdᵖ struct{}

func (*TransformFeedbackIdᵖ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdᵖ)(nil)
}
func doEncodeTransformFeedbackIdᵖ(e binary.Encoder, o *TransformFeedbackIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeTransformFeedbackIdᵖ(d binary.Decoder, o *TransformFeedbackIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipTransformFeedbackIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTransformFeedbackIdᵖ) ID() binary.ID      { return binaryIDTransformFeedbackIdᵖ }
func (*binaryClassTransformFeedbackIdᵖ) New() binary.Object { return &TransformFeedbackIdᵖ{} }
func (*binaryClassTransformFeedbackIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTransformFeedbackIdᵖ(e, obj.(*TransformFeedbackIdᵖ))
}
func (*binaryClassTransformFeedbackIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TransformFeedbackIdᵖ{}
	return obj, doDecodeTransformFeedbackIdᵖ(d, obj)
}
func (*binaryClassTransformFeedbackIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTransformFeedbackIdᵖ(d, obj.(*TransformFeedbackIdᵖ))
}
func (*binaryClassTransformFeedbackIdᵖ) Skip(d binary.Decoder) error {
	return doSkipTransformFeedbackIdᵖ(d)
}
func (*binaryClassTransformFeedbackIdᵖ) Schema() *schema.Class { return schemaTransformFeedbackIdᵖ }

var schemaTransformFeedbackIdᵖ = &schema.Class{
	TypeID:  binaryIDTransformFeedbackIdᵖ,
	Package: "gles",
	Name:    "TransformFeedbackIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGenTransformFeedbacks struct{}

func (*GlGenTransformFeedbacks) Class() binary.Class {
	return (*binaryClassGlGenTransformFeedbacks)(nil)
}
func doEncodeGlGenTransformFeedbacks(e binary.Encoder, o *GlGenTransformFeedbacks) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.N)); err != nil {
		return err
	}
	if err := e.Value(&o.Ids); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenTransformFeedbacks(d binary.Decoder, o *GlGenTransformFeedbacks) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.N = GLsizei(obj)
	}
	if err := d.Value(&o.Ids); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenTransformFeedbacks(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TransformFeedbackIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenTransformFeedbacks) ID() binary.ID      { return binaryIDGlGenTransformFeedbacks }
func (*binaryClassGlGenTransformFeedbacks) New() binary.Object { return &GlGenTransformFeedbacks{} }
func (*binaryClassGlGenTransformFeedbacks) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenTransformFeedbacks(e, obj.(*GlGenTransformFeedbacks))
}
func (*binaryClassGlGenTransformFeedbacks) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenTransformFeedbacks{}
	return obj, doDecodeGlGenTransformFeedbacks(d, obj)
}
func (*binaryClassGlGenTransformFeedbacks) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenTransformFeedbacks(d, obj.(*GlGenTransformFeedbacks))
}
func (*binaryClassGlGenTransformFeedbacks) Skip(d binary.Decoder) error {
	return doSkipGlGenTransformFeedbacks(d)
}
func (*binaryClassGlGenTransformFeedbacks) Schema() *schema.Class {
	return schemaGlGenTransformFeedbacks
}

var schemaGlGenTransformFeedbacks = &schema.Class{
	TypeID:  binaryIDGlGenTransformFeedbacks,
	Package: "gles",
	Name:    "GlGenTransformFeedbacks",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "N", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Ids", Type: &schema.Struct{Name: "TransformFeedbackIdᵖ", ID: (*TransformFeedbackIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassVertexArrayIdᵖ struct{}

func (*VertexArrayIdᵖ) Class() binary.Class {
	return (*binaryClassVertexArrayIdᵖ)(nil)
}
func doEncodeVertexArrayIdᵖ(e binary.Encoder, o *VertexArrayIdᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexArrayIdᵖ(d binary.Decoder, o *VertexArrayIdᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVertexArrayIdᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexArrayIdᵖ) ID() binary.ID      { return binaryIDVertexArrayIdᵖ }
func (*binaryClassVertexArrayIdᵖ) New() binary.Object { return &VertexArrayIdᵖ{} }
func (*binaryClassVertexArrayIdᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexArrayIdᵖ(e, obj.(*VertexArrayIdᵖ))
}
func (*binaryClassVertexArrayIdᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexArrayIdᵖ{}
	return obj, doDecodeVertexArrayIdᵖ(d, obj)
}
func (*binaryClassVertexArrayIdᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexArrayIdᵖ(d, obj.(*VertexArrayIdᵖ))
}
func (*binaryClassVertexArrayIdᵖ) Skip(d binary.Decoder) error { return doSkipVertexArrayIdᵖ(d) }
func (*binaryClassVertexArrayIdᵖ) Schema() *schema.Class       { return schemaVertexArrayIdᵖ }

var schemaVertexArrayIdᵖ = &schema.Class{
	TypeID:  binaryIDVertexArrayIdᵖ,
	Package: "gles",
	Name:    "VertexArrayIdᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGenVertexArrays struct{}

func (*GlGenVertexArrays) Class() binary.Class {
	return (*binaryClassGlGenVertexArrays)(nil)
}
func doEncodeGlGenVertexArrays(e binary.Encoder, o *GlGenVertexArrays) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenVertexArrays(d binary.Decoder, o *GlGenVertexArrays) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenVertexArrays(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexArrayIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenVertexArrays) ID() binary.ID      { return binaryIDGlGenVertexArrays }
func (*binaryClassGlGenVertexArrays) New() binary.Object { return &GlGenVertexArrays{} }
func (*binaryClassGlGenVertexArrays) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenVertexArrays(e, obj.(*GlGenVertexArrays))
}
func (*binaryClassGlGenVertexArrays) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenVertexArrays{}
	return obj, doDecodeGlGenVertexArrays(d, obj)
}
func (*binaryClassGlGenVertexArrays) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenVertexArrays(d, obj.(*GlGenVertexArrays))
}
func (*binaryClassGlGenVertexArrays) Skip(d binary.Decoder) error { return doSkipGlGenVertexArrays(d) }
func (*binaryClassGlGenVertexArrays) Schema() *schema.Class       { return schemaGlGenVertexArrays }

var schemaGlGenVertexArrays = &schema.Class{
	TypeID:  binaryIDGlGenVertexArrays,
	Package: "gles",
	Name:    "GlGenVertexArrays",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᵖ", ID: (*VertexArrayIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenVertexArraysOES struct{}

func (*GlGenVertexArraysOES) Class() binary.Class {
	return (*binaryClassGlGenVertexArraysOES)(nil)
}
func doEncodeGlGenVertexArraysOES(e binary.Encoder, o *GlGenVertexArraysOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenVertexArraysOES(d binary.Decoder, o *GlGenVertexArraysOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Arrays); err != nil {
		return err
	}
	return nil
}
func doSkipGlGenVertexArraysOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexArrayIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenVertexArraysOES) ID() binary.ID      { return binaryIDGlGenVertexArraysOES }
func (*binaryClassGlGenVertexArraysOES) New() binary.Object { return &GlGenVertexArraysOES{} }
func (*binaryClassGlGenVertexArraysOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenVertexArraysOES(e, obj.(*GlGenVertexArraysOES))
}
func (*binaryClassGlGenVertexArraysOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenVertexArraysOES{}
	return obj, doDecodeGlGenVertexArraysOES(d, obj)
}
func (*binaryClassGlGenVertexArraysOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenVertexArraysOES(d, obj.(*GlGenVertexArraysOES))
}
func (*binaryClassGlGenVertexArraysOES) Skip(d binary.Decoder) error {
	return doSkipGlGenVertexArraysOES(d)
}
func (*binaryClassGlGenVertexArraysOES) Schema() *schema.Class { return schemaGlGenVertexArraysOES }

var schemaGlGenVertexArraysOES = &schema.Class{
	TypeID:  binaryIDGlGenVertexArraysOES,
	Package: "gles",
	Name:    "GlGenVertexArraysOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Arrays", Type: &schema.Struct{Name: "VertexArrayIdᵖ", ID: (*VertexArrayIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGenerateMipmap struct{}

func (*GlGenerateMipmap) Class() binary.Class {
	return (*binaryClassGlGenerateMipmap)(nil)
}
func doEncodeGlGenerateMipmap(e binary.Encoder, o *GlGenerateMipmap) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGenerateMipmap(d binary.Decoder, o *GlGenerateMipmap) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	return nil
}
func doSkipGlGenerateMipmap(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGenerateMipmap) ID() binary.ID      { return binaryIDGlGenerateMipmap }
func (*binaryClassGlGenerateMipmap) New() binary.Object { return &GlGenerateMipmap{} }
func (*binaryClassGlGenerateMipmap) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGenerateMipmap(e, obj.(*GlGenerateMipmap))
}
func (*binaryClassGlGenerateMipmap) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGenerateMipmap{}
	return obj, doDecodeGlGenerateMipmap(d, obj)
}
func (*binaryClassGlGenerateMipmap) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGenerateMipmap(d, obj.(*GlGenerateMipmap))
}
func (*binaryClassGlGenerateMipmap) Skip(d binary.Decoder) error { return doSkipGlGenerateMipmap(d) }
func (*binaryClassGlGenerateMipmap) Schema() *schema.Class       { return schemaGlGenerateMipmap }

var schemaGlGenerateMipmap = &schema.Class{
	TypeID:  binaryIDGlGenerateMipmap,
	Package: "gles",
	Name:    "GlGenerateMipmap",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlGetActiveAttrib struct{}

func (*GlGetActiveAttrib) Class() binary.Class {
	return (*binaryClassGlGetActiveAttrib)(nil)
}
func doEncodeGlGetActiveAttrib(e binary.Encoder, o *GlGetActiveAttrib) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferSize)); err != nil {
		return err
	}
	if err := e.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := e.Value(&o.VectorCount); err != nil {
		return err
	}
	if err := e.Value(&o.Type); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetActiveAttrib(d binary.Decoder, o *GlGetActiveAttrib) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferSize = GLsizei(obj)
	}
	if err := d.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := d.Value(&o.VectorCount); err != nil {
		return err
	}
	if err := d.Value(&o.Type); err != nil {
		return err
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetActiveAttrib(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetActiveAttrib) ID() binary.ID      { return binaryIDGlGetActiveAttrib }
func (*binaryClassGlGetActiveAttrib) New() binary.Object { return &GlGetActiveAttrib{} }
func (*binaryClassGlGetActiveAttrib) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetActiveAttrib(e, obj.(*GlGetActiveAttrib))
}
func (*binaryClassGlGetActiveAttrib) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetActiveAttrib{}
	return obj, doDecodeGlGetActiveAttrib(d, obj)
}
func (*binaryClassGlGetActiveAttrib) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetActiveAttrib(d, obj.(*GlGetActiveAttrib))
}
func (*binaryClassGlGetActiveAttrib) Skip(d binary.Decoder) error { return doSkipGlGetActiveAttrib(d) }
func (*binaryClassGlGetActiveAttrib) Schema() *schema.Class       { return schemaGlGetActiveAttrib }

var schemaGlGetActiveAttrib = &schema.Class{
	TypeID:  binaryIDGlGetActiveAttrib,
	Package: "gles",
	Name:    "GlGetActiveAttrib",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "BufferSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "BufferBytesWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "VectorCount", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetActiveUniform struct{}

func (*GlGetActiveUniform) Class() binary.Class {
	return (*binaryClassGlGetActiveUniform)(nil)
}
func doEncodeGlGetActiveUniform(e binary.Encoder, o *GlGetActiveUniform) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferSize)); err != nil {
		return err
	}
	if err := e.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := e.Value(&o.VectorCount); err != nil {
		return err
	}
	if err := e.Value(&o.Type); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetActiveUniform(d binary.Decoder, o *GlGetActiveUniform) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferSize = GLsizei(obj)
	}
	if err := d.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := d.Value(&o.VectorCount); err != nil {
		return err
	}
	if err := d.Value(&o.Type); err != nil {
		return err
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetActiveUniform(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetActiveUniform) ID() binary.ID      { return binaryIDGlGetActiveUniform }
func (*binaryClassGlGetActiveUniform) New() binary.Object { return &GlGetActiveUniform{} }
func (*binaryClassGlGetActiveUniform) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetActiveUniform(e, obj.(*GlGetActiveUniform))
}
func (*binaryClassGlGetActiveUniform) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetActiveUniform{}
	return obj, doDecodeGlGetActiveUniform(d, obj)
}
func (*binaryClassGlGetActiveUniform) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetActiveUniform(d, obj.(*GlGetActiveUniform))
}
func (*binaryClassGlGetActiveUniform) Skip(d binary.Decoder) error { return doSkipGlGetActiveUniform(d) }
func (*binaryClassGlGetActiveUniform) Schema() *schema.Class       { return schemaGlGetActiveUniform }

var schemaGlGetActiveUniform = &schema.Class{
	TypeID:  binaryIDGlGetActiveUniform,
	Package: "gles",
	Name:    "GlGetActiveUniform",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufferSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "BufferBytesWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "VectorCount", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetActiveUniformBlockName struct{}

func (*GlGetActiveUniformBlockName) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformBlockName)(nil)
}
func doEncodeGlGetActiveUniformBlockName(e binary.Encoder, o *GlGetActiveUniformBlockName) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.UniformBlockIndex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferSize)); err != nil {
		return err
	}
	if err := e.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetActiveUniformBlockName(d binary.Decoder, o *GlGetActiveUniformBlockName) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.UniformBlockIndex = UniformBlockId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferSize = GLsizei(obj)
	}
	if err := d.Value(&o.BufferBytesWritten); err != nil {
		return err
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetActiveUniformBlockName(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetActiveUniformBlockName) ID() binary.ID {
	return binaryIDGlGetActiveUniformBlockName
}
func (*binaryClassGlGetActiveUniformBlockName) New() binary.Object {
	return &GlGetActiveUniformBlockName{}
}
func (*binaryClassGlGetActiveUniformBlockName) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetActiveUniformBlockName(e, obj.(*GlGetActiveUniformBlockName))
}
func (*binaryClassGlGetActiveUniformBlockName) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetActiveUniformBlockName{}
	return obj, doDecodeGlGetActiveUniformBlockName(d, obj)
}
func (*binaryClassGlGetActiveUniformBlockName) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetActiveUniformBlockName(d, obj.(*GlGetActiveUniformBlockName))
}
func (*binaryClassGlGetActiveUniformBlockName) Skip(d binary.Decoder) error {
	return doSkipGlGetActiveUniformBlockName(d)
}
func (*binaryClassGlGetActiveUniformBlockName) Schema() *schema.Class {
	return schemaGlGetActiveUniformBlockName
}

var schemaGlGetActiveUniformBlockName = &schema.Class{
	TypeID:  binaryIDGlGetActiveUniformBlockName,
	Package: "gles",
	Name:    "GlGetActiveUniformBlockName",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformBlockIndex", Type: &schema.Primitive{Name: "UniformBlockId", Method: schema.Uint32}},
		{Declared: "BufferSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "BufferBytesWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetActiveUniformBlockiv struct{}

func (*GlGetActiveUniformBlockiv) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformBlockiv)(nil)
}
func doEncodeGlGetActiveUniformBlockiv(e binary.Encoder, o *GlGetActiveUniformBlockiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.UniformBlockIndex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ParameterName)); err != nil {
		return err
	}
	if err := e.Value(&o.Parameters); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetActiveUniformBlockiv(d binary.Decoder, o *GlGetActiveUniformBlockiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.UniformBlockIndex = UniformBlockId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ParameterName = GLenum(obj)
	}
	if err := d.Value(&o.Parameters); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetActiveUniformBlockiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetActiveUniformBlockiv) ID() binary.ID      { return binaryIDGlGetActiveUniformBlockiv }
func (*binaryClassGlGetActiveUniformBlockiv) New() binary.Object { return &GlGetActiveUniformBlockiv{} }
func (*binaryClassGlGetActiveUniformBlockiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetActiveUniformBlockiv(e, obj.(*GlGetActiveUniformBlockiv))
}
func (*binaryClassGlGetActiveUniformBlockiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetActiveUniformBlockiv{}
	return obj, doDecodeGlGetActiveUniformBlockiv(d, obj)
}
func (*binaryClassGlGetActiveUniformBlockiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetActiveUniformBlockiv(d, obj.(*GlGetActiveUniformBlockiv))
}
func (*binaryClassGlGetActiveUniformBlockiv) Skip(d binary.Decoder) error {
	return doSkipGlGetActiveUniformBlockiv(d)
}
func (*binaryClassGlGetActiveUniformBlockiv) Schema() *schema.Class {
	return schemaGlGetActiveUniformBlockiv
}

var schemaGlGetActiveUniformBlockiv = &schema.Class{
	TypeID:  binaryIDGlGetActiveUniformBlockiv,
	Package: "gles",
	Name:    "GlGetActiveUniformBlockiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformBlockIndex", Type: &schema.Primitive{Name: "UniformBlockId", Method: schema.Uint32}},
		{Declared: "ParameterName", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameters", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetActiveUniformsiv struct{}

func (*GlGetActiveUniformsiv) Class() binary.Class {
	return (*binaryClassGlGetActiveUniformsiv)(nil)
}
func doEncodeGlGetActiveUniformsiv(e binary.Encoder, o *GlGetActiveUniformsiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.UniformCount)); err != nil {
		return err
	}
	if err := e.Value(&o.UniformIndices); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ParameterName)); err != nil {
		return err
	}
	if err := e.Value(&o.Parameters); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetActiveUniformsiv(d binary.Decoder, o *GlGetActiveUniformsiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.UniformCount = GLsizei(obj)
	}
	if err := d.Value(&o.UniformIndices); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ParameterName = GLenum(obj)
	}
	if err := d.Value(&o.Parameters); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetActiveUniformsiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetActiveUniformsiv) ID() binary.ID      { return binaryIDGlGetActiveUniformsiv }
func (*binaryClassGlGetActiveUniformsiv) New() binary.Object { return &GlGetActiveUniformsiv{} }
func (*binaryClassGlGetActiveUniformsiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetActiveUniformsiv(e, obj.(*GlGetActiveUniformsiv))
}
func (*binaryClassGlGetActiveUniformsiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetActiveUniformsiv{}
	return obj, doDecodeGlGetActiveUniformsiv(d, obj)
}
func (*binaryClassGlGetActiveUniformsiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetActiveUniformsiv(d, obj.(*GlGetActiveUniformsiv))
}
func (*binaryClassGlGetActiveUniformsiv) Skip(d binary.Decoder) error {
	return doSkipGlGetActiveUniformsiv(d)
}
func (*binaryClassGlGetActiveUniformsiv) Schema() *schema.Class { return schemaGlGetActiveUniformsiv }

var schemaGlGetActiveUniformsiv = &schema.Class{
	TypeID:  binaryIDGlGetActiveUniformsiv,
	Package: "gles",
	Name:    "GlGetActiveUniformsiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "UniformIndices", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
		{Declared: "ParameterName", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameters", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetAttachedShaders struct{}

func (*GlGetAttachedShaders) Class() binary.Class {
	return (*binaryClassGlGetAttachedShaders)(nil)
}
func doEncodeGlGetAttachedShaders(e binary.Encoder, o *GlGetAttachedShaders) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferLength)); err != nil {
		return err
	}
	if err := e.Value(&o.ShadersLengthWritten); err != nil {
		return err
	}
	if err := e.Value(&o.Shaders); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetAttachedShaders(d binary.Decoder, o *GlGetAttachedShaders) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferLength = GLsizei(obj)
	}
	if err := d.Value(&o.ShadersLengthWritten); err != nil {
		return err
	}
	if err := d.Value(&o.Shaders); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetAttachedShaders(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ShaderIdᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetAttachedShaders) ID() binary.ID      { return binaryIDGlGetAttachedShaders }
func (*binaryClassGlGetAttachedShaders) New() binary.Object { return &GlGetAttachedShaders{} }
func (*binaryClassGlGetAttachedShaders) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetAttachedShaders(e, obj.(*GlGetAttachedShaders))
}
func (*binaryClassGlGetAttachedShaders) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetAttachedShaders{}
	return obj, doDecodeGlGetAttachedShaders(d, obj)
}
func (*binaryClassGlGetAttachedShaders) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetAttachedShaders(d, obj.(*GlGetAttachedShaders))
}
func (*binaryClassGlGetAttachedShaders) Skip(d binary.Decoder) error {
	return doSkipGlGetAttachedShaders(d)
}
func (*binaryClassGlGetAttachedShaders) Schema() *schema.Class { return schemaGlGetAttachedShaders }

var schemaGlGetAttachedShaders = &schema.Class{
	TypeID:  binaryIDGlGetAttachedShaders,
	Package: "gles",
	Name:    "GlGetAttachedShaders",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BufferLength", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "ShadersLengthWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Shaders", Type: &schema.Struct{Name: "ShaderIdᵖ", ID: (*ShaderIdᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetAttribLocation struct{}

func (*GlGetAttribLocation) Class() binary.Class {
	return (*binaryClassGlGetAttribLocation)(nil)
}
func doEncodeGlGetAttribLocation(e binary.Encoder, o *GlGetAttribLocation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetAttribLocation(d binary.Decoder, o *GlGetAttribLocation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Result = GLint(obj)
	}
	return nil
}
func doSkipGlGetAttribLocation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetAttribLocation) ID() binary.ID      { return binaryIDGlGetAttribLocation }
func (*binaryClassGlGetAttribLocation) New() binary.Object { return &GlGetAttribLocation{} }
func (*binaryClassGlGetAttribLocation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetAttribLocation(e, obj.(*GlGetAttribLocation))
}
func (*binaryClassGlGetAttribLocation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetAttribLocation{}
	return obj, doDecodeGlGetAttribLocation(d, obj)
}
func (*binaryClassGlGetAttribLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetAttribLocation(d, obj.(*GlGetAttribLocation))
}
func (*binaryClassGlGetAttribLocation) Skip(d binary.Decoder) error {
	return doSkipGlGetAttribLocation(d)
}
func (*binaryClassGlGetAttribLocation) Schema() *schema.Class { return schemaGlGetAttribLocation }

var schemaGlGetAttribLocation = &schema.Class{
	TypeID:  binaryIDGlGetAttribLocation,
	Package: "gles",
	Name:    "GlGetAttribLocation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlGetBooleani_v struct{}

func (*GlGetBooleani_v) Class() binary.Class {
	return (*binaryClassGlGetBooleani_v)(nil)
}
func doEncodeGlGetBooleani_v(e binary.Encoder, o *GlGetBooleani_v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBooleani_v(d binary.Decoder, o *GlGetBooleani_v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBooleani_v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLbooleanᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBooleani_v) ID() binary.ID      { return binaryIDGlGetBooleani_v }
func (*binaryClassGlGetBooleani_v) New() binary.Object { return &GlGetBooleani_v{} }
func (*binaryClassGlGetBooleani_v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBooleani_v(e, obj.(*GlGetBooleani_v))
}
func (*binaryClassGlGetBooleani_v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBooleani_v{}
	return obj, doDecodeGlGetBooleani_v(d, obj)
}
func (*binaryClassGlGetBooleani_v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBooleani_v(d, obj.(*GlGetBooleani_v))
}
func (*binaryClassGlGetBooleani_v) Skip(d binary.Decoder) error { return doSkipGlGetBooleani_v(d) }
func (*binaryClassGlGetBooleani_v) Schema() *schema.Class       { return schemaGlGetBooleani_v }

var schemaGlGetBooleani_v = &schema.Class{
	TypeID:  binaryIDGlGetBooleani_v,
	Package: "gles",
	Name:    "GlGetBooleani_v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLbooleanᵖ", ID: (*GLbooleanᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetBooleanv struct{}

func (*GlGetBooleanv) Class() binary.Class {
	return (*binaryClassGlGetBooleanv)(nil)
}
func doEncodeGlGetBooleanv(e binary.Encoder, o *GlGetBooleanv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Param)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBooleanv(d binary.Decoder, o *GlGetBooleanv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Param = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBooleanv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLbooleanᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBooleanv) ID() binary.ID      { return binaryIDGlGetBooleanv }
func (*binaryClassGlGetBooleanv) New() binary.Object { return &GlGetBooleanv{} }
func (*binaryClassGlGetBooleanv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBooleanv(e, obj.(*GlGetBooleanv))
}
func (*binaryClassGlGetBooleanv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBooleanv{}
	return obj, doDecodeGlGetBooleanv(d, obj)
}
func (*binaryClassGlGetBooleanv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBooleanv(d, obj.(*GlGetBooleanv))
}
func (*binaryClassGlGetBooleanv) Skip(d binary.Decoder) error { return doSkipGlGetBooleanv(d) }
func (*binaryClassGlGetBooleanv) Schema() *schema.Class       { return schemaGlGetBooleanv }

var schemaGlGetBooleanv = &schema.Class{
	TypeID:  binaryIDGlGetBooleanv,
	Package: "gles",
	Name:    "GlGetBooleanv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLbooleanᵖ", ID: (*GLbooleanᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetBufferParameteri64v struct{}

func (*GlGetBufferParameteri64v) Class() binary.Class {
	return (*binaryClassGlGetBufferParameteri64v)(nil)
}
func doEncodeGlGetBufferParameteri64v(e binary.Encoder, o *GlGetBufferParameteri64v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBufferParameteri64v(d binary.Decoder, o *GlGetBufferParameteri64v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBufferParameteri64v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBufferParameteri64v) ID() binary.ID      { return binaryIDGlGetBufferParameteri64v }
func (*binaryClassGlGetBufferParameteri64v) New() binary.Object { return &GlGetBufferParameteri64v{} }
func (*binaryClassGlGetBufferParameteri64v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBufferParameteri64v(e, obj.(*GlGetBufferParameteri64v))
}
func (*binaryClassGlGetBufferParameteri64v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBufferParameteri64v{}
	return obj, doDecodeGlGetBufferParameteri64v(d, obj)
}
func (*binaryClassGlGetBufferParameteri64v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBufferParameteri64v(d, obj.(*GlGetBufferParameteri64v))
}
func (*binaryClassGlGetBufferParameteri64v) Skip(d binary.Decoder) error {
	return doSkipGlGetBufferParameteri64v(d)
}
func (*binaryClassGlGetBufferParameteri64v) Schema() *schema.Class {
	return schemaGlGetBufferParameteri64v
}

var schemaGlGetBufferParameteri64v = &schema.Class{
	TypeID:  binaryIDGlGetBufferParameteri64v,
	Package: "gles",
	Name:    "GlGetBufferParameteri64v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLint64ᵖ", ID: (*GLint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetBufferParameteriv struct{}

func (*GlGetBufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetBufferParameteriv)(nil)
}
func doEncodeGlGetBufferParameteriv(e binary.Encoder, o *GlGetBufferParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBufferParameteriv(d binary.Decoder, o *GlGetBufferParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBufferParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBufferParameteriv) ID() binary.ID      { return binaryIDGlGetBufferParameteriv }
func (*binaryClassGlGetBufferParameteriv) New() binary.Object { return &GlGetBufferParameteriv{} }
func (*binaryClassGlGetBufferParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBufferParameteriv(e, obj.(*GlGetBufferParameteriv))
}
func (*binaryClassGlGetBufferParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBufferParameteriv{}
	return obj, doDecodeGlGetBufferParameteriv(d, obj)
}
func (*binaryClassGlGetBufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBufferParameteriv(d, obj.(*GlGetBufferParameteriv))
}
func (*binaryClassGlGetBufferParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetBufferParameteriv(d)
}
func (*binaryClassGlGetBufferParameteriv) Schema() *schema.Class { return schemaGlGetBufferParameteriv }

var schemaGlGetBufferParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetBufferParameteriv,
	Package: "gles",
	Name:    "GlGetBufferParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetBufferPointerv struct{}

func (*GlGetBufferPointerv) Class() binary.Class {
	return (*binaryClassGlGetBufferPointerv)(nil)
}
func doEncodeGlGetBufferPointerv(e binary.Encoder, o *GlGetBufferPointerv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBufferPointerv(d binary.Decoder, o *GlGetBufferPointerv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBufferPointerv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBufferPointerv) ID() binary.ID      { return binaryIDGlGetBufferPointerv }
func (*binaryClassGlGetBufferPointerv) New() binary.Object { return &GlGetBufferPointerv{} }
func (*binaryClassGlGetBufferPointerv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBufferPointerv(e, obj.(*GlGetBufferPointerv))
}
func (*binaryClassGlGetBufferPointerv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBufferPointerv{}
	return obj, doDecodeGlGetBufferPointerv(d, obj)
}
func (*binaryClassGlGetBufferPointerv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBufferPointerv(d, obj.(*GlGetBufferPointerv))
}
func (*binaryClassGlGetBufferPointerv) Skip(d binary.Decoder) error {
	return doSkipGlGetBufferPointerv(d)
}
func (*binaryClassGlGetBufferPointerv) Schema() *schema.Class { return schemaGlGetBufferPointerv }

var schemaGlGetBufferPointerv = &schema.Class{
	TypeID:  binaryIDGlGetBufferPointerv,
	Package: "gles",
	Name:    "GlGetBufferPointerv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "Voidᵖᵖ", ID: (*Voidᵖᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetBufferPointervOES struct{}

func (*GlGetBufferPointervOES) Class() binary.Class {
	return (*binaryClassGlGetBufferPointervOES)(nil)
}
func doEncodeGlGetBufferPointervOES(e binary.Encoder, o *GlGetBufferPointervOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetBufferPointervOES(d binary.Decoder, o *GlGetBufferPointervOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetBufferPointervOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetBufferPointervOES) ID() binary.ID      { return binaryIDGlGetBufferPointervOES }
func (*binaryClassGlGetBufferPointervOES) New() binary.Object { return &GlGetBufferPointervOES{} }
func (*binaryClassGlGetBufferPointervOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetBufferPointervOES(e, obj.(*GlGetBufferPointervOES))
}
func (*binaryClassGlGetBufferPointervOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetBufferPointervOES{}
	return obj, doDecodeGlGetBufferPointervOES(d, obj)
}
func (*binaryClassGlGetBufferPointervOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetBufferPointervOES(d, obj.(*GlGetBufferPointervOES))
}
func (*binaryClassGlGetBufferPointervOES) Skip(d binary.Decoder) error {
	return doSkipGlGetBufferPointervOES(d)
}
func (*binaryClassGlGetBufferPointervOES) Schema() *schema.Class { return schemaGlGetBufferPointervOES }

var schemaGlGetBufferPointervOES = &schema.Class{
	TypeID:  binaryIDGlGetBufferPointervOES,
	Package: "gles",
	Name:    "GlGetBufferPointervOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "Voidᵖᵖ", ID: (*Voidᵖᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetCoverageModulationTableNV struct{}

func (*GlGetCoverageModulationTableNV) Class() binary.Class {
	return (*binaryClassGlGetCoverageModulationTableNV)(nil)
}
func doEncodeGlGetCoverageModulationTableNV(e binary.Encoder, o *GlGetCoverageModulationTableNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Bufsize)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetCoverageModulationTableNV(d binary.Decoder, o *GlGetCoverageModulationTableNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Bufsize = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetCoverageModulationTableNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetCoverageModulationTableNV) ID() binary.ID {
	return binaryIDGlGetCoverageModulationTableNV
}
func (*binaryClassGlGetCoverageModulationTableNV) New() binary.Object {
	return &GlGetCoverageModulationTableNV{}
}
func (*binaryClassGlGetCoverageModulationTableNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetCoverageModulationTableNV(e, obj.(*GlGetCoverageModulationTableNV))
}
func (*binaryClassGlGetCoverageModulationTableNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetCoverageModulationTableNV{}
	return obj, doDecodeGlGetCoverageModulationTableNV(d, obj)
}
func (*binaryClassGlGetCoverageModulationTableNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetCoverageModulationTableNV(d, obj.(*GlGetCoverageModulationTableNV))
}
func (*binaryClassGlGetCoverageModulationTableNV) Skip(d binary.Decoder) error {
	return doSkipGlGetCoverageModulationTableNV(d)
}
func (*binaryClassGlGetCoverageModulationTableNV) Schema() *schema.Class {
	return schemaGlGetCoverageModulationTableNV
}

var schemaGlGetCoverageModulationTableNV = &schema.Class{
	TypeID:  binaryIDGlGetCoverageModulationTableNV,
	Package: "gles",
	Name:    "GlGetCoverageModulationTableNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Bufsize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetDebugMessageLogKHR struct{}

func (*GlGetDebugMessageLogKHR) Class() binary.Class {
	return (*binaryClassGlGetDebugMessageLogKHR)(nil)
}
func doEncodeGlGetDebugMessageLogKHR(e binary.Encoder, o *GlGetDebugMessageLogKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Count)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Sources); err != nil {
		return err
	}
	if err := e.Value(&o.Types); err != nil {
		return err
	}
	if err := e.Value(&o.Ids); err != nil {
		return err
	}
	if err := e.Value(&o.Severities); err != nil {
		return err
	}
	if err := e.Value(&o.Lengths); err != nil {
		return err
	}
	if err := e.Value(&o.MessageLog); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetDebugMessageLogKHR(d binary.Decoder, o *GlGetDebugMessageLogKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Count = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Sources); err != nil {
		return err
	}
	if err := d.Value(&o.Types); err != nil {
		return err
	}
	if err := d.Value(&o.Ids); err != nil {
		return err
	}
	if err := d.Value(&o.Severities); err != nil {
		return err
	}
	if err := d.Value(&o.Lengths); err != nil {
		return err
	}
	if err := d.Value(&o.MessageLog); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLuint(obj)
	}
	return nil
}
func doSkipGlGetDebugMessageLogKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetDebugMessageLogKHR) ID() binary.ID      { return binaryIDGlGetDebugMessageLogKHR }
func (*binaryClassGlGetDebugMessageLogKHR) New() binary.Object { return &GlGetDebugMessageLogKHR{} }
func (*binaryClassGlGetDebugMessageLogKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetDebugMessageLogKHR(e, obj.(*GlGetDebugMessageLogKHR))
}
func (*binaryClassGlGetDebugMessageLogKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetDebugMessageLogKHR{}
	return obj, doDecodeGlGetDebugMessageLogKHR(d, obj)
}
func (*binaryClassGlGetDebugMessageLogKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetDebugMessageLogKHR(d, obj.(*GlGetDebugMessageLogKHR))
}
func (*binaryClassGlGetDebugMessageLogKHR) Skip(d binary.Decoder) error {
	return doSkipGlGetDebugMessageLogKHR(d)
}
func (*binaryClassGlGetDebugMessageLogKHR) Schema() *schema.Class {
	return schemaGlGetDebugMessageLogKHR
}

var schemaGlGetDebugMessageLogKHR = &schema.Class{
	TypeID:  binaryIDGlGetDebugMessageLogKHR,
	Package: "gles",
	Name:    "GlGetDebugMessageLogKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Sources", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Types", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Ids", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "Severities", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Lengths", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "MessageLog", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlGetDriverControlStringQCOM struct{}

func (*GlGetDriverControlStringQCOM) Class() binary.Class {
	return (*binaryClassGlGetDriverControlStringQCOM)(nil)
}
func doEncodeGlGetDriverControlStringQCOM(e binary.Encoder, o *GlGetDriverControlStringQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.DriverControl)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.DriverControlString); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetDriverControlStringQCOM(d binary.Decoder, o *GlGetDriverControlStringQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.DriverControl = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.DriverControlString); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetDriverControlStringQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetDriverControlStringQCOM) ID() binary.ID {
	return binaryIDGlGetDriverControlStringQCOM
}
func (*binaryClassGlGetDriverControlStringQCOM) New() binary.Object {
	return &GlGetDriverControlStringQCOM{}
}
func (*binaryClassGlGetDriverControlStringQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetDriverControlStringQCOM(e, obj.(*GlGetDriverControlStringQCOM))
}
func (*binaryClassGlGetDriverControlStringQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetDriverControlStringQCOM{}
	return obj, doDecodeGlGetDriverControlStringQCOM(d, obj)
}
func (*binaryClassGlGetDriverControlStringQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetDriverControlStringQCOM(d, obj.(*GlGetDriverControlStringQCOM))
}
func (*binaryClassGlGetDriverControlStringQCOM) Skip(d binary.Decoder) error {
	return doSkipGlGetDriverControlStringQCOM(d)
}
func (*binaryClassGlGetDriverControlStringQCOM) Schema() *schema.Class {
	return schemaGlGetDriverControlStringQCOM
}

var schemaGlGetDriverControlStringQCOM = &schema.Class{
	TypeID:  binaryIDGlGetDriverControlStringQCOM,
	Package: "gles",
	Name:    "GlGetDriverControlStringQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "DriverControl", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "DriverControlString", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetDriverControlsQCOM struct{}

func (*GlGetDriverControlsQCOM) Class() binary.Class {
	return (*binaryClassGlGetDriverControlsQCOM)(nil)
}
func doEncodeGlGetDriverControlsQCOM(e binary.Encoder, o *GlGetDriverControlsQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Num); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Value(&o.DriverControls); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetDriverControlsQCOM(d binary.Decoder, o *GlGetDriverControlsQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Num); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizei(obj)
	}
	if err := d.Value(&o.DriverControls); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetDriverControlsQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetDriverControlsQCOM) ID() binary.ID      { return binaryIDGlGetDriverControlsQCOM }
func (*binaryClassGlGetDriverControlsQCOM) New() binary.Object { return &GlGetDriverControlsQCOM{} }
func (*binaryClassGlGetDriverControlsQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetDriverControlsQCOM(e, obj.(*GlGetDriverControlsQCOM))
}
func (*binaryClassGlGetDriverControlsQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetDriverControlsQCOM{}
	return obj, doDecodeGlGetDriverControlsQCOM(d, obj)
}
func (*binaryClassGlGetDriverControlsQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetDriverControlsQCOM(d, obj.(*GlGetDriverControlsQCOM))
}
func (*binaryClassGlGetDriverControlsQCOM) Skip(d binary.Decoder) error {
	return doSkipGlGetDriverControlsQCOM(d)
}
func (*binaryClassGlGetDriverControlsQCOM) Schema() *schema.Class {
	return schemaGlGetDriverControlsQCOM
}

var schemaGlGetDriverControlsQCOM = &schema.Class{
	TypeID:  binaryIDGlGetDriverControlsQCOM,
	Package: "gles",
	Name:    "GlGetDriverControlsQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Num", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "DriverControls", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetError struct{}

func (*GlGetError) Class() binary.Class {
	return (*binaryClassGlGetError)(nil)
}
func doEncodeGlGetError(e binary.Encoder, o *GlGetError) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetError(d binary.Decoder, o *GlGetError) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlGetError(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetError) ID() binary.ID      { return binaryIDGlGetError }
func (*binaryClassGlGetError) New() binary.Object { return &GlGetError{} }
func (*binaryClassGlGetError) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetError(e, obj.(*GlGetError))
}
func (*binaryClassGlGetError) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetError{}
	return obj, doDecodeGlGetError(d, obj)
}
func (*binaryClassGlGetError) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetError(d, obj.(*GlGetError))
}
func (*binaryClassGlGetError) Skip(d binary.Decoder) error { return doSkipGlGetError(d) }
func (*binaryClassGlGetError) Schema() *schema.Class       { return schemaGlGetError }

var schemaGlGetError = &schema.Class{
	TypeID:  binaryIDGlGetError,
	Package: "gles",
	Name:    "GlGetError",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlGetFenceivNV struct{}

func (*GlGetFenceivNV) Class() binary.Class {
	return (*binaryClassGlGetFenceivNV)(nil)
}
func doEncodeGlGetFenceivNV(e binary.Encoder, o *GlGetFenceivNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fence)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFenceivNV(d binary.Decoder, o *GlGetFenceivNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fence = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFenceivNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFenceivNV) ID() binary.ID      { return binaryIDGlGetFenceivNV }
func (*binaryClassGlGetFenceivNV) New() binary.Object { return &GlGetFenceivNV{} }
func (*binaryClassGlGetFenceivNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFenceivNV(e, obj.(*GlGetFenceivNV))
}
func (*binaryClassGlGetFenceivNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFenceivNV{}
	return obj, doDecodeGlGetFenceivNV(d, obj)
}
func (*binaryClassGlGetFenceivNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFenceivNV(d, obj.(*GlGetFenceivNV))
}
func (*binaryClassGlGetFenceivNV) Skip(d binary.Decoder) error { return doSkipGlGetFenceivNV(d) }
func (*binaryClassGlGetFenceivNV) Schema() *schema.Class       { return schemaGlGetFenceivNV }

var schemaGlGetFenceivNV = &schema.Class{
	TypeID:  binaryIDGlGetFenceivNV,
	Package: "gles",
	Name:    "GlGetFenceivNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetFirstPerfQueryIdINTEL struct{}

func (*GlGetFirstPerfQueryIdINTEL) Class() binary.Class {
	return (*binaryClassGlGetFirstPerfQueryIdINTEL)(nil)
}
func doEncodeGlGetFirstPerfQueryIdINTEL(e binary.Encoder, o *GlGetFirstPerfQueryIdINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.QueryId); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFirstPerfQueryIdINTEL(d binary.Decoder, o *GlGetFirstPerfQueryIdINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.QueryId); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFirstPerfQueryIdINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) ID() binary.ID {
	return binaryIDGlGetFirstPerfQueryIdINTEL
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) New() binary.Object {
	return &GlGetFirstPerfQueryIdINTEL{}
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFirstPerfQueryIdINTEL(e, obj.(*GlGetFirstPerfQueryIdINTEL))
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFirstPerfQueryIdINTEL{}
	return obj, doDecodeGlGetFirstPerfQueryIdINTEL(d, obj)
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFirstPerfQueryIdINTEL(d, obj.(*GlGetFirstPerfQueryIdINTEL))
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetFirstPerfQueryIdINTEL(d)
}
func (*binaryClassGlGetFirstPerfQueryIdINTEL) Schema() *schema.Class {
	return schemaGlGetFirstPerfQueryIdINTEL
}

var schemaGlGetFirstPerfQueryIdINTEL = &schema.Class{
	TypeID:  binaryIDGlGetFirstPerfQueryIdINTEL,
	Package: "gles",
	Name:    "GlGetFirstPerfQueryIdINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetFloati_vNV struct{}

func (*GlGetFloati_vNV) Class() binary.Class {
	return (*binaryClassGlGetFloati_vNV)(nil)
}
func doEncodeGlGetFloati_vNV(e binary.Encoder, o *GlGetFloati_vNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFloati_vNV(d binary.Decoder, o *GlGetFloati_vNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFloati_vNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFloati_vNV) ID() binary.ID      { return binaryIDGlGetFloati_vNV }
func (*binaryClassGlGetFloati_vNV) New() binary.Object { return &GlGetFloati_vNV{} }
func (*binaryClassGlGetFloati_vNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFloati_vNV(e, obj.(*GlGetFloati_vNV))
}
func (*binaryClassGlGetFloati_vNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFloati_vNV{}
	return obj, doDecodeGlGetFloati_vNV(d, obj)
}
func (*binaryClassGlGetFloati_vNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFloati_vNV(d, obj.(*GlGetFloati_vNV))
}
func (*binaryClassGlGetFloati_vNV) Skip(d binary.Decoder) error { return doSkipGlGetFloati_vNV(d) }
func (*binaryClassGlGetFloati_vNV) Schema() *schema.Class       { return schemaGlGetFloati_vNV }

var schemaGlGetFloati_vNV = &schema.Class{
	TypeID:  binaryIDGlGetFloati_vNV,
	Package: "gles",
	Name:    "GlGetFloati_vNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetFloatv struct{}

func (*GlGetFloatv) Class() binary.Class {
	return (*binaryClassGlGetFloatv)(nil)
}
func doEncodeGlGetFloatv(e binary.Encoder, o *GlGetFloatv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Param)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFloatv(d binary.Decoder, o *GlGetFloatv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Param = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFloatv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFloatv) ID() binary.ID      { return binaryIDGlGetFloatv }
func (*binaryClassGlGetFloatv) New() binary.Object { return &GlGetFloatv{} }
func (*binaryClassGlGetFloatv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFloatv(e, obj.(*GlGetFloatv))
}
func (*binaryClassGlGetFloatv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFloatv{}
	return obj, doDecodeGlGetFloatv(d, obj)
}
func (*binaryClassGlGetFloatv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFloatv(d, obj.(*GlGetFloatv))
}
func (*binaryClassGlGetFloatv) Skip(d binary.Decoder) error { return doSkipGlGetFloatv(d) }
func (*binaryClassGlGetFloatv) Schema() *schema.Class       { return schemaGlGetFloatv }

var schemaGlGetFloatv = &schema.Class{
	TypeID:  binaryIDGlGetFloatv,
	Package: "gles",
	Name:    "GlGetFloatv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetFragDataLocation struct{}

func (*GlGetFragDataLocation) Class() binary.Class {
	return (*binaryClassGlGetFragDataLocation)(nil)
}
func doEncodeGlGetFragDataLocation(e binary.Encoder, o *GlGetFragDataLocation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFragDataLocation(d binary.Decoder, o *GlGetFragDataLocation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Result = GLint(obj)
	}
	return nil
}
func doSkipGlGetFragDataLocation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFragDataLocation) ID() binary.ID      { return binaryIDGlGetFragDataLocation }
func (*binaryClassGlGetFragDataLocation) New() binary.Object { return &GlGetFragDataLocation{} }
func (*binaryClassGlGetFragDataLocation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFragDataLocation(e, obj.(*GlGetFragDataLocation))
}
func (*binaryClassGlGetFragDataLocation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFragDataLocation{}
	return obj, doDecodeGlGetFragDataLocation(d, obj)
}
func (*binaryClassGlGetFragDataLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFragDataLocation(d, obj.(*GlGetFragDataLocation))
}
func (*binaryClassGlGetFragDataLocation) Skip(d binary.Decoder) error {
	return doSkipGlGetFragDataLocation(d)
}
func (*binaryClassGlGetFragDataLocation) Schema() *schema.Class { return schemaGlGetFragDataLocation }

var schemaGlGetFragDataLocation = &schema.Class{
	TypeID:  binaryIDGlGetFragDataLocation,
	Package: "gles",
	Name:    "GlGetFragDataLocation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlGetFramebufferAttachmentParameteriv struct{}

func (*GlGetFramebufferAttachmentParameteriv) Class() binary.Class {
	return (*binaryClassGlGetFramebufferAttachmentParameteriv)(nil)
}
func doEncodeGlGetFramebufferAttachmentParameteriv(e binary.Encoder, o *GlGetFramebufferAttachmentParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FramebufferTarget)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attachment)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFramebufferAttachmentParameteriv(d binary.Decoder, o *GlGetFramebufferAttachmentParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FramebufferTarget = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attachment = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFramebufferAttachmentParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) ID() binary.ID {
	return binaryIDGlGetFramebufferAttachmentParameteriv
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) New() binary.Object {
	return &GlGetFramebufferAttachmentParameteriv{}
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFramebufferAttachmentParameteriv(e, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFramebufferAttachmentParameteriv{}
	return obj, doDecodeGlGetFramebufferAttachmentParameteriv(d, obj)
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFramebufferAttachmentParameteriv(d, obj.(*GlGetFramebufferAttachmentParameteriv))
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetFramebufferAttachmentParameteriv(d)
}
func (*binaryClassGlGetFramebufferAttachmentParameteriv) Schema() *schema.Class {
	return schemaGlGetFramebufferAttachmentParameteriv
}

var schemaGlGetFramebufferAttachmentParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetFramebufferAttachmentParameteriv,
	Package: "gles",
	Name:    "GlGetFramebufferAttachmentParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FramebufferTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Attachment", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetFramebufferParameteriv struct{}

func (*GlGetFramebufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetFramebufferParameteriv)(nil)
}
func doEncodeGlGetFramebufferParameteriv(e binary.Encoder, o *GlGetFramebufferParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetFramebufferParameteriv(d binary.Decoder, o *GlGetFramebufferParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetFramebufferParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetFramebufferParameteriv) ID() binary.ID {
	return binaryIDGlGetFramebufferParameteriv
}
func (*binaryClassGlGetFramebufferParameteriv) New() binary.Object {
	return &GlGetFramebufferParameteriv{}
}
func (*binaryClassGlGetFramebufferParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetFramebufferParameteriv(e, obj.(*GlGetFramebufferParameteriv))
}
func (*binaryClassGlGetFramebufferParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetFramebufferParameteriv{}
	return obj, doDecodeGlGetFramebufferParameteriv(d, obj)
}
func (*binaryClassGlGetFramebufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetFramebufferParameteriv(d, obj.(*GlGetFramebufferParameteriv))
}
func (*binaryClassGlGetFramebufferParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetFramebufferParameteriv(d)
}
func (*binaryClassGlGetFramebufferParameteriv) Schema() *schema.Class {
	return schemaGlGetFramebufferParameteriv
}

var schemaGlGetFramebufferParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetFramebufferParameteriv,
	Package: "gles",
	Name:    "GlGetFramebufferParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetGraphicsResetStatusEXT struct{}

func (*GlGetGraphicsResetStatusEXT) Class() binary.Class {
	return (*binaryClassGlGetGraphicsResetStatusEXT)(nil)
}
func doEncodeGlGetGraphicsResetStatusEXT(e binary.Encoder, o *GlGetGraphicsResetStatusEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetGraphicsResetStatusEXT(d binary.Decoder, o *GlGetGraphicsResetStatusEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlGetGraphicsResetStatusEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetGraphicsResetStatusEXT) ID() binary.ID {
	return binaryIDGlGetGraphicsResetStatusEXT
}
func (*binaryClassGlGetGraphicsResetStatusEXT) New() binary.Object {
	return &GlGetGraphicsResetStatusEXT{}
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetGraphicsResetStatusEXT(e, obj.(*GlGetGraphicsResetStatusEXT))
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetGraphicsResetStatusEXT{}
	return obj, doDecodeGlGetGraphicsResetStatusEXT(d, obj)
}
func (*binaryClassGlGetGraphicsResetStatusEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetGraphicsResetStatusEXT(d, obj.(*GlGetGraphicsResetStatusEXT))
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetGraphicsResetStatusEXT(d)
}
func (*binaryClassGlGetGraphicsResetStatusEXT) Schema() *schema.Class {
	return schemaGlGetGraphicsResetStatusEXT
}

var schemaGlGetGraphicsResetStatusEXT = &schema.Class{
	TypeID:  binaryIDGlGetGraphicsResetStatusEXT,
	Package: "gles",
	Name:    "GlGetGraphicsResetStatusEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlGetGraphicsResetStatusKHR struct{}

func (*GlGetGraphicsResetStatusKHR) Class() binary.Class {
	return (*binaryClassGlGetGraphicsResetStatusKHR)(nil)
}
func doEncodeGlGetGraphicsResetStatusKHR(e binary.Encoder, o *GlGetGraphicsResetStatusKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetGraphicsResetStatusKHR(d binary.Decoder, o *GlGetGraphicsResetStatusKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlGetGraphicsResetStatusKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetGraphicsResetStatusKHR) ID() binary.ID {
	return binaryIDGlGetGraphicsResetStatusKHR
}
func (*binaryClassGlGetGraphicsResetStatusKHR) New() binary.Object {
	return &GlGetGraphicsResetStatusKHR{}
}
func (*binaryClassGlGetGraphicsResetStatusKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetGraphicsResetStatusKHR(e, obj.(*GlGetGraphicsResetStatusKHR))
}
func (*binaryClassGlGetGraphicsResetStatusKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetGraphicsResetStatusKHR{}
	return obj, doDecodeGlGetGraphicsResetStatusKHR(d, obj)
}
func (*binaryClassGlGetGraphicsResetStatusKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetGraphicsResetStatusKHR(d, obj.(*GlGetGraphicsResetStatusKHR))
}
func (*binaryClassGlGetGraphicsResetStatusKHR) Skip(d binary.Decoder) error {
	return doSkipGlGetGraphicsResetStatusKHR(d)
}
func (*binaryClassGlGetGraphicsResetStatusKHR) Schema() *schema.Class {
	return schemaGlGetGraphicsResetStatusKHR
}

var schemaGlGetGraphicsResetStatusKHR = &schema.Class{
	TypeID:  binaryIDGlGetGraphicsResetStatusKHR,
	Package: "gles",
	Name:    "GlGetGraphicsResetStatusKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlGetImageHandleNV struct{}

func (*GlGetImageHandleNV) Class() binary.Class {
	return (*binaryClassGlGetImageHandleNV)(nil)
}
func doEncodeGlGetImageHandleNV(e binary.Encoder, o *GlGetImageHandleNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Layered)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Layer)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetImageHandleNV(d binary.Decoder, o *GlGetImageHandleNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Layered = GLboolean(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Layer = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = GLuint64(obj)
	}
	return nil
}
func doSkipGlGetImageHandleNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetImageHandleNV) ID() binary.ID      { return binaryIDGlGetImageHandleNV }
func (*binaryClassGlGetImageHandleNV) New() binary.Object { return &GlGetImageHandleNV{} }
func (*binaryClassGlGetImageHandleNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetImageHandleNV(e, obj.(*GlGetImageHandleNV))
}
func (*binaryClassGlGetImageHandleNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetImageHandleNV{}
	return obj, doDecodeGlGetImageHandleNV(d, obj)
}
func (*binaryClassGlGetImageHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetImageHandleNV(d, obj.(*GlGetImageHandleNV))
}
func (*binaryClassGlGetImageHandleNV) Skip(d binary.Decoder) error { return doSkipGlGetImageHandleNV(d) }
func (*binaryClassGlGetImageHandleNV) Schema() *schema.Class       { return schemaGlGetImageHandleNV }

var schemaGlGetImageHandleNV = &schema.Class{
	TypeID:  binaryIDGlGetImageHandleNV,
	Package: "gles",
	Name:    "GlGetImageHandleNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Layered", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Layer", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlGetInteger64i_v struct{}

func (*GlGetInteger64i_v) Class() binary.Class {
	return (*binaryClassGlGetInteger64i_v)(nil)
}
func doEncodeGlGetInteger64i_v(e binary.Encoder, o *GlGetInteger64i_v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetInteger64i_v(d binary.Decoder, o *GlGetInteger64i_v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetInteger64i_v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetInteger64i_v) ID() binary.ID      { return binaryIDGlGetInteger64i_v }
func (*binaryClassGlGetInteger64i_v) New() binary.Object { return &GlGetInteger64i_v{} }
func (*binaryClassGlGetInteger64i_v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetInteger64i_v(e, obj.(*GlGetInteger64i_v))
}
func (*binaryClassGlGetInteger64i_v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetInteger64i_v{}
	return obj, doDecodeGlGetInteger64i_v(d, obj)
}
func (*binaryClassGlGetInteger64i_v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetInteger64i_v(d, obj.(*GlGetInteger64i_v))
}
func (*binaryClassGlGetInteger64i_v) Skip(d binary.Decoder) error { return doSkipGlGetInteger64i_v(d) }
func (*binaryClassGlGetInteger64i_v) Schema() *schema.Class       { return schemaGlGetInteger64i_v }

var schemaGlGetInteger64i_v = &schema.Class{
	TypeID:  binaryIDGlGetInteger64i_v,
	Package: "gles",
	Name:    "GlGetInteger64i_v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLint64ᵖ", ID: (*GLint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetInteger64v struct{}

func (*GlGetInteger64v) Class() binary.Class {
	return (*binaryClassGlGetInteger64v)(nil)
}
func doEncodeGlGetInteger64v(e binary.Encoder, o *GlGetInteger64v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetInteger64v(d binary.Decoder, o *GlGetInteger64v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetInteger64v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetInteger64v) ID() binary.ID      { return binaryIDGlGetInteger64v }
func (*binaryClassGlGetInteger64v) New() binary.Object { return &GlGetInteger64v{} }
func (*binaryClassGlGetInteger64v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetInteger64v(e, obj.(*GlGetInteger64v))
}
func (*binaryClassGlGetInteger64v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetInteger64v{}
	return obj, doDecodeGlGetInteger64v(d, obj)
}
func (*binaryClassGlGetInteger64v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetInteger64v(d, obj.(*GlGetInteger64v))
}
func (*binaryClassGlGetInteger64v) Skip(d binary.Decoder) error { return doSkipGlGetInteger64v(d) }
func (*binaryClassGlGetInteger64v) Schema() *schema.Class       { return schemaGlGetInteger64v }

var schemaGlGetInteger64v = &schema.Class{
	TypeID:  binaryIDGlGetInteger64v,
	Package: "gles",
	Name:    "GlGetInteger64v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLint64ᵖ", ID: (*GLint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetInteger64vAPPLE struct{}

func (*GlGetInteger64vAPPLE) Class() binary.Class {
	return (*binaryClassGlGetInteger64vAPPLE)(nil)
}
func doEncodeGlGetInteger64vAPPLE(e binary.Encoder, o *GlGetInteger64vAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetInteger64vAPPLE(d binary.Decoder, o *GlGetInteger64vAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetInteger64vAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetInteger64vAPPLE) ID() binary.ID      { return binaryIDGlGetInteger64vAPPLE }
func (*binaryClassGlGetInteger64vAPPLE) New() binary.Object { return &GlGetInteger64vAPPLE{} }
func (*binaryClassGlGetInteger64vAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetInteger64vAPPLE(e, obj.(*GlGetInteger64vAPPLE))
}
func (*binaryClassGlGetInteger64vAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetInteger64vAPPLE{}
	return obj, doDecodeGlGetInteger64vAPPLE(d, obj)
}
func (*binaryClassGlGetInteger64vAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetInteger64vAPPLE(d, obj.(*GlGetInteger64vAPPLE))
}
func (*binaryClassGlGetInteger64vAPPLE) Skip(d binary.Decoder) error {
	return doSkipGlGetInteger64vAPPLE(d)
}
func (*binaryClassGlGetInteger64vAPPLE) Schema() *schema.Class { return schemaGlGetInteger64vAPPLE }

var schemaGlGetInteger64vAPPLE = &schema.Class{
	TypeID:  binaryIDGlGetInteger64vAPPLE,
	Package: "gles",
	Name:    "GlGetInteger64vAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLint64ᵖ", ID: (*GLint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetIntegeri_v struct{}

func (*GlGetIntegeri_v) Class() binary.Class {
	return (*binaryClassGlGetIntegeri_v)(nil)
}
func doEncodeGlGetIntegeri_v(e binary.Encoder, o *GlGetIntegeri_v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetIntegeri_v(d binary.Decoder, o *GlGetIntegeri_v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetIntegeri_v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetIntegeri_v) ID() binary.ID      { return binaryIDGlGetIntegeri_v }
func (*binaryClassGlGetIntegeri_v) New() binary.Object { return &GlGetIntegeri_v{} }
func (*binaryClassGlGetIntegeri_v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetIntegeri_v(e, obj.(*GlGetIntegeri_v))
}
func (*binaryClassGlGetIntegeri_v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetIntegeri_v{}
	return obj, doDecodeGlGetIntegeri_v(d, obj)
}
func (*binaryClassGlGetIntegeri_v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetIntegeri_v(d, obj.(*GlGetIntegeri_v))
}
func (*binaryClassGlGetIntegeri_v) Skip(d binary.Decoder) error { return doSkipGlGetIntegeri_v(d) }
func (*binaryClassGlGetIntegeri_v) Schema() *schema.Class       { return schemaGlGetIntegeri_v }

var schemaGlGetIntegeri_v = &schema.Class{
	TypeID:  binaryIDGlGetIntegeri_v,
	Package: "gles",
	Name:    "GlGetIntegeri_v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetIntegeri_vEXT struct{}

func (*GlGetIntegeri_vEXT) Class() binary.Class {
	return (*binaryClassGlGetIntegeri_vEXT)(nil)
}
func doEncodeGlGetIntegeri_vEXT(e binary.Encoder, o *GlGetIntegeri_vEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetIntegeri_vEXT(d binary.Decoder, o *GlGetIntegeri_vEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetIntegeri_vEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetIntegeri_vEXT) ID() binary.ID      { return binaryIDGlGetIntegeri_vEXT }
func (*binaryClassGlGetIntegeri_vEXT) New() binary.Object { return &GlGetIntegeri_vEXT{} }
func (*binaryClassGlGetIntegeri_vEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetIntegeri_vEXT(e, obj.(*GlGetIntegeri_vEXT))
}
func (*binaryClassGlGetIntegeri_vEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetIntegeri_vEXT{}
	return obj, doDecodeGlGetIntegeri_vEXT(d, obj)
}
func (*binaryClassGlGetIntegeri_vEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetIntegeri_vEXT(d, obj.(*GlGetIntegeri_vEXT))
}
func (*binaryClassGlGetIntegeri_vEXT) Skip(d binary.Decoder) error { return doSkipGlGetIntegeri_vEXT(d) }
func (*binaryClassGlGetIntegeri_vEXT) Schema() *schema.Class       { return schemaGlGetIntegeri_vEXT }

var schemaGlGetIntegeri_vEXT = &schema.Class{
	TypeID:  binaryIDGlGetIntegeri_vEXT,
	Package: "gles",
	Name:    "GlGetIntegeri_vEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetIntegerv struct{}

func (*GlGetIntegerv) Class() binary.Class {
	return (*binaryClassGlGetIntegerv)(nil)
}
func doEncodeGlGetIntegerv(e binary.Encoder, o *GlGetIntegerv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Param)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetIntegerv(d binary.Decoder, o *GlGetIntegerv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Param = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetIntegerv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetIntegerv) ID() binary.ID      { return binaryIDGlGetIntegerv }
func (*binaryClassGlGetIntegerv) New() binary.Object { return &GlGetIntegerv{} }
func (*binaryClassGlGetIntegerv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetIntegerv(e, obj.(*GlGetIntegerv))
}
func (*binaryClassGlGetIntegerv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetIntegerv{}
	return obj, doDecodeGlGetIntegerv(d, obj)
}
func (*binaryClassGlGetIntegerv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetIntegerv(d, obj.(*GlGetIntegerv))
}
func (*binaryClassGlGetIntegerv) Skip(d binary.Decoder) error { return doSkipGlGetIntegerv(d) }
func (*binaryClassGlGetIntegerv) Schema() *schema.Class       { return schemaGlGetIntegerv }

var schemaGlGetIntegerv = &schema.Class{
	TypeID:  binaryIDGlGetIntegerv,
	Package: "gles",
	Name:    "GlGetIntegerv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetInternalformatSampleivNV struct{}

func (*GlGetInternalformatSampleivNV) Class() binary.Class {
	return (*binaryClassGlGetInternalformatSampleivNV)(nil)
}
func doEncodeGlGetInternalformatSampleivNV(e binary.Encoder, o *GlGetInternalformatSampleivNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetInternalformatSampleivNV(d binary.Decoder, o *GlGetInternalformatSampleivNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetInternalformatSampleivNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetInternalformatSampleivNV) ID() binary.ID {
	return binaryIDGlGetInternalformatSampleivNV
}
func (*binaryClassGlGetInternalformatSampleivNV) New() binary.Object {
	return &GlGetInternalformatSampleivNV{}
}
func (*binaryClassGlGetInternalformatSampleivNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetInternalformatSampleivNV(e, obj.(*GlGetInternalformatSampleivNV))
}
func (*binaryClassGlGetInternalformatSampleivNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetInternalformatSampleivNV{}
	return obj, doDecodeGlGetInternalformatSampleivNV(d, obj)
}
func (*binaryClassGlGetInternalformatSampleivNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetInternalformatSampleivNV(d, obj.(*GlGetInternalformatSampleivNV))
}
func (*binaryClassGlGetInternalformatSampleivNV) Skip(d binary.Decoder) error {
	return doSkipGlGetInternalformatSampleivNV(d)
}
func (*binaryClassGlGetInternalformatSampleivNV) Schema() *schema.Class {
	return schemaGlGetInternalformatSampleivNV
}

var schemaGlGetInternalformatSampleivNV = &schema.Class{
	TypeID:  binaryIDGlGetInternalformatSampleivNV,
	Package: "gles",
	Name:    "GlGetInternalformatSampleivNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetInternalformativ struct{}

func (*GlGetInternalformativ) Class() binary.Class {
	return (*binaryClassGlGetInternalformativ)(nil)
}
func doEncodeGlGetInternalformativ(e binary.Encoder, o *GlGetInternalformativ) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetInternalformativ(d binary.Decoder, o *GlGetInternalformativ) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetInternalformativ(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetInternalformativ) ID() binary.ID      { return binaryIDGlGetInternalformativ }
func (*binaryClassGlGetInternalformativ) New() binary.Object { return &GlGetInternalformativ{} }
func (*binaryClassGlGetInternalformativ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetInternalformativ(e, obj.(*GlGetInternalformativ))
}
func (*binaryClassGlGetInternalformativ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetInternalformativ{}
	return obj, doDecodeGlGetInternalformativ(d, obj)
}
func (*binaryClassGlGetInternalformativ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetInternalformativ(d, obj.(*GlGetInternalformativ))
}
func (*binaryClassGlGetInternalformativ) Skip(d binary.Decoder) error {
	return doSkipGlGetInternalformativ(d)
}
func (*binaryClassGlGetInternalformativ) Schema() *schema.Class { return schemaGlGetInternalformativ }

var schemaGlGetInternalformativ = &schema.Class{
	TypeID:  binaryIDGlGetInternalformativ,
	Package: "gles",
	Name:    "GlGetInternalformativ",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetMultisamplefv struct{}

func (*GlGetMultisamplefv) Class() binary.Class {
	return (*binaryClassGlGetMultisamplefv)(nil)
}
func doEncodeGlGetMultisamplefv(e binary.Encoder, o *GlGetMultisamplefv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Val); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetMultisamplefv(d binary.Decoder, o *GlGetMultisamplefv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Val); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetMultisamplefv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetMultisamplefv) ID() binary.ID      { return binaryIDGlGetMultisamplefv }
func (*binaryClassGlGetMultisamplefv) New() binary.Object { return &GlGetMultisamplefv{} }
func (*binaryClassGlGetMultisamplefv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetMultisamplefv(e, obj.(*GlGetMultisamplefv))
}
func (*binaryClassGlGetMultisamplefv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetMultisamplefv{}
	return obj, doDecodeGlGetMultisamplefv(d, obj)
}
func (*binaryClassGlGetMultisamplefv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetMultisamplefv(d, obj.(*GlGetMultisamplefv))
}
func (*binaryClassGlGetMultisamplefv) Skip(d binary.Decoder) error { return doSkipGlGetMultisamplefv(d) }
func (*binaryClassGlGetMultisamplefv) Schema() *schema.Class       { return schemaGlGetMultisamplefv }

var schemaGlGetMultisamplefv = &schema.Class{
	TypeID:  binaryIDGlGetMultisamplefv,
	Package: "gles",
	Name:    "GlGetMultisamplefv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Val", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetNextPerfQueryIdINTEL struct{}

func (*GlGetNextPerfQueryIdINTEL) Class() binary.Class {
	return (*binaryClassGlGetNextPerfQueryIdINTEL)(nil)
}
func doEncodeGlGetNextPerfQueryIdINTEL(e binary.Encoder, o *GlGetNextPerfQueryIdINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryId)); err != nil {
		return err
	}
	if err := e.Value(&o.NextQueryId); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetNextPerfQueryIdINTEL(d binary.Decoder, o *GlGetNextPerfQueryIdINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryId = GLuint(obj)
	}
	if err := d.Value(&o.NextQueryId); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetNextPerfQueryIdINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) ID() binary.ID      { return binaryIDGlGetNextPerfQueryIdINTEL }
func (*binaryClassGlGetNextPerfQueryIdINTEL) New() binary.Object { return &GlGetNextPerfQueryIdINTEL{} }
func (*binaryClassGlGetNextPerfQueryIdINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetNextPerfQueryIdINTEL(e, obj.(*GlGetNextPerfQueryIdINTEL))
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetNextPerfQueryIdINTEL{}
	return obj, doDecodeGlGetNextPerfQueryIdINTEL(d, obj)
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetNextPerfQueryIdINTEL(d, obj.(*GlGetNextPerfQueryIdINTEL))
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetNextPerfQueryIdINTEL(d)
}
func (*binaryClassGlGetNextPerfQueryIdINTEL) Schema() *schema.Class {
	return schemaGlGetNextPerfQueryIdINTEL
}

var schemaGlGetNextPerfQueryIdINTEL = &schema.Class{
	TypeID:  binaryIDGlGetNextPerfQueryIdINTEL,
	Package: "gles",
	Name:    "GlGetNextPerfQueryIdINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NextQueryId", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetObjectLabelEXT struct{}

func (*GlGetObjectLabelEXT) Class() binary.Class {
	return (*binaryClassGlGetObjectLabelEXT)(nil)
}
func doEncodeGlGetObjectLabelEXT(e binary.Encoder, o *GlGetObjectLabelEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Object)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetObjectLabelEXT(d binary.Decoder, o *GlGetObjectLabelEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Object = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetObjectLabelEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetObjectLabelEXT) ID() binary.ID      { return binaryIDGlGetObjectLabelEXT }
func (*binaryClassGlGetObjectLabelEXT) New() binary.Object { return &GlGetObjectLabelEXT{} }
func (*binaryClassGlGetObjectLabelEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetObjectLabelEXT(e, obj.(*GlGetObjectLabelEXT))
}
func (*binaryClassGlGetObjectLabelEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetObjectLabelEXT{}
	return obj, doDecodeGlGetObjectLabelEXT(d, obj)
}
func (*binaryClassGlGetObjectLabelEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetObjectLabelEXT(d, obj.(*GlGetObjectLabelEXT))
}
func (*binaryClassGlGetObjectLabelEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetObjectLabelEXT(d)
}
func (*binaryClassGlGetObjectLabelEXT) Schema() *schema.Class { return schemaGlGetObjectLabelEXT }

var schemaGlGetObjectLabelEXT = &schema.Class{
	TypeID:  binaryIDGlGetObjectLabelEXT,
	Package: "gles",
	Name:    "GlGetObjectLabelEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Object", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetObjectLabelKHR struct{}

func (*GlGetObjectLabelKHR) Class() binary.Class {
	return (*binaryClassGlGetObjectLabelKHR)(nil)
}
func doEncodeGlGetObjectLabelKHR(e binary.Encoder, o *GlGetObjectLabelKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Identifier)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Name)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetObjectLabelKHR(d binary.Decoder, o *GlGetObjectLabelKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Identifier = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Name = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetObjectLabelKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetObjectLabelKHR) ID() binary.ID      { return binaryIDGlGetObjectLabelKHR }
func (*binaryClassGlGetObjectLabelKHR) New() binary.Object { return &GlGetObjectLabelKHR{} }
func (*binaryClassGlGetObjectLabelKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetObjectLabelKHR(e, obj.(*GlGetObjectLabelKHR))
}
func (*binaryClassGlGetObjectLabelKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetObjectLabelKHR{}
	return obj, doDecodeGlGetObjectLabelKHR(d, obj)
}
func (*binaryClassGlGetObjectLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetObjectLabelKHR(d, obj.(*GlGetObjectLabelKHR))
}
func (*binaryClassGlGetObjectLabelKHR) Skip(d binary.Decoder) error {
	return doSkipGlGetObjectLabelKHR(d)
}
func (*binaryClassGlGetObjectLabelKHR) Schema() *schema.Class { return schemaGlGetObjectLabelKHR }

var schemaGlGetObjectLabelKHR = &schema.Class{
	TypeID:  binaryIDGlGetObjectLabelKHR,
	Package: "gles",
	Name:    "GlGetObjectLabelKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Identifier", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetObjectPtrLabelKHR struct{}

func (*GlGetObjectPtrLabelKHR) Class() binary.Class {
	return (*binaryClassGlGetObjectPtrLabelKHR)(nil)
}
func doEncodeGlGetObjectPtrLabelKHR(e binary.Encoder, o *GlGetObjectPtrLabelKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Ptr); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetObjectPtrLabelKHR(d binary.Decoder, o *GlGetObjectPtrLabelKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Ptr); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetObjectPtrLabelKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetObjectPtrLabelKHR) ID() binary.ID      { return binaryIDGlGetObjectPtrLabelKHR }
func (*binaryClassGlGetObjectPtrLabelKHR) New() binary.Object { return &GlGetObjectPtrLabelKHR{} }
func (*binaryClassGlGetObjectPtrLabelKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetObjectPtrLabelKHR(e, obj.(*GlGetObjectPtrLabelKHR))
}
func (*binaryClassGlGetObjectPtrLabelKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetObjectPtrLabelKHR{}
	return obj, doDecodeGlGetObjectPtrLabelKHR(d, obj)
}
func (*binaryClassGlGetObjectPtrLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetObjectPtrLabelKHR(d, obj.(*GlGetObjectPtrLabelKHR))
}
func (*binaryClassGlGetObjectPtrLabelKHR) Skip(d binary.Decoder) error {
	return doSkipGlGetObjectPtrLabelKHR(d)
}
func (*binaryClassGlGetObjectPtrLabelKHR) Schema() *schema.Class { return schemaGlGetObjectPtrLabelKHR }

var schemaGlGetObjectPtrLabelKHR = &schema.Class{
	TypeID:  binaryIDGlGetObjectPtrLabelKHR,
	Package: "gles",
	Name:    "GlGetObjectPtrLabelKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Ptr", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathCommandsNV struct{}

func (*GlGetPathCommandsNV) Class() binary.Class {
	return (*binaryClassGlGetPathCommandsNV)(nil)
}
func doEncodeGlGetPathCommandsNV(e binary.Encoder, o *GlGetPathCommandsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Value(&o.Commands); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathCommandsNV(d binary.Decoder, o *GlGetPathCommandsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if err := d.Value(&o.Commands); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathCommandsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLubyteᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathCommandsNV) ID() binary.ID      { return binaryIDGlGetPathCommandsNV }
func (*binaryClassGlGetPathCommandsNV) New() binary.Object { return &GlGetPathCommandsNV{} }
func (*binaryClassGlGetPathCommandsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathCommandsNV(e, obj.(*GlGetPathCommandsNV))
}
func (*binaryClassGlGetPathCommandsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathCommandsNV{}
	return obj, doDecodeGlGetPathCommandsNV(d, obj)
}
func (*binaryClassGlGetPathCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathCommandsNV(d, obj.(*GlGetPathCommandsNV))
}
func (*binaryClassGlGetPathCommandsNV) Skip(d binary.Decoder) error {
	return doSkipGlGetPathCommandsNV(d)
}
func (*binaryClassGlGetPathCommandsNV) Schema() *schema.Class { return schemaGlGetPathCommandsNV }

var schemaGlGetPathCommandsNV = &schema.Class{
	TypeID:  binaryIDGlGetPathCommandsNV,
	Package: "gles",
	Name:    "GlGetPathCommandsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Commands", Type: &schema.Struct{Name: "GLubyteᵖ", ID: (*GLubyteᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathCoordsNV struct{}

func (*GlGetPathCoordsNV) Class() binary.Class {
	return (*binaryClassGlGetPathCoordsNV)(nil)
}
func doEncodeGlGetPathCoordsNV(e binary.Encoder, o *GlGetPathCoordsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathCoordsNV(d binary.Decoder, o *GlGetPathCoordsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if err := d.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathCoordsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathCoordsNV) ID() binary.ID      { return binaryIDGlGetPathCoordsNV }
func (*binaryClassGlGetPathCoordsNV) New() binary.Object { return &GlGetPathCoordsNV{} }
func (*binaryClassGlGetPathCoordsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathCoordsNV(e, obj.(*GlGetPathCoordsNV))
}
func (*binaryClassGlGetPathCoordsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathCoordsNV{}
	return obj, doDecodeGlGetPathCoordsNV(d, obj)
}
func (*binaryClassGlGetPathCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathCoordsNV(d, obj.(*GlGetPathCoordsNV))
}
func (*binaryClassGlGetPathCoordsNV) Skip(d binary.Decoder) error { return doSkipGlGetPathCoordsNV(d) }
func (*binaryClassGlGetPathCoordsNV) Schema() *schema.Class       { return schemaGlGetPathCoordsNV }

var schemaGlGetPathCoordsNV = &schema.Class{
	TypeID:  binaryIDGlGetPathCoordsNV,
	Package: "gles",
	Name:    "GlGetPathCoordsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Coords", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathDashArrayNV struct{}

func (*GlGetPathDashArrayNV) Class() binary.Class {
	return (*binaryClassGlGetPathDashArrayNV)(nil)
}
func doEncodeGlGetPathDashArrayNV(e binary.Encoder, o *GlGetPathDashArrayNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Value(&o.DashArray); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathDashArrayNV(d binary.Decoder, o *GlGetPathDashArrayNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if err := d.Value(&o.DashArray); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathDashArrayNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathDashArrayNV) ID() binary.ID      { return binaryIDGlGetPathDashArrayNV }
func (*binaryClassGlGetPathDashArrayNV) New() binary.Object { return &GlGetPathDashArrayNV{} }
func (*binaryClassGlGetPathDashArrayNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathDashArrayNV(e, obj.(*GlGetPathDashArrayNV))
}
func (*binaryClassGlGetPathDashArrayNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathDashArrayNV{}
	return obj, doDecodeGlGetPathDashArrayNV(d, obj)
}
func (*binaryClassGlGetPathDashArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathDashArrayNV(d, obj.(*GlGetPathDashArrayNV))
}
func (*binaryClassGlGetPathDashArrayNV) Skip(d binary.Decoder) error {
	return doSkipGlGetPathDashArrayNV(d)
}
func (*binaryClassGlGetPathDashArrayNV) Schema() *schema.Class { return schemaGlGetPathDashArrayNV }

var schemaGlGetPathDashArrayNV = &schema.Class{
	TypeID:  binaryIDGlGetPathDashArrayNV,
	Package: "gles",
	Name:    "GlGetPathDashArrayNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "DashArray", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathLengthNV struct{}

func (*GlGetPathLengthNV) Class() binary.Class {
	return (*binaryClassGlGetPathLengthNV)(nil)
}
func doEncodeGlGetPathLengthNV(e binary.Encoder, o *GlGetPathLengthNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.StartSegment)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumSegments)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathLengthNV(d binary.Decoder, o *GlGetPathLengthNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.StartSegment = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumSegments = GLsizei(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Result = GLfloat(obj)
	}
	return nil
}
func doSkipGlGetPathLengthNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathLengthNV) ID() binary.ID      { return binaryIDGlGetPathLengthNV }
func (*binaryClassGlGetPathLengthNV) New() binary.Object { return &GlGetPathLengthNV{} }
func (*binaryClassGlGetPathLengthNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathLengthNV(e, obj.(*GlGetPathLengthNV))
}
func (*binaryClassGlGetPathLengthNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathLengthNV{}
	return obj, doDecodeGlGetPathLengthNV(d, obj)
}
func (*binaryClassGlGetPathLengthNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathLengthNV(d, obj.(*GlGetPathLengthNV))
}
func (*binaryClassGlGetPathLengthNV) Skip(d binary.Decoder) error { return doSkipGlGetPathLengthNV(d) }
func (*binaryClassGlGetPathLengthNV) Schema() *schema.Class       { return schemaGlGetPathLengthNV }

var schemaGlGetPathLengthNV = &schema.Class{
	TypeID:  binaryIDGlGetPathLengthNV,
	Package: "gles",
	Name:    "GlGetPathLengthNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "StartSegment", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "NumSegments", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlGetPathMetricRangeNV struct{}

func (*GlGetPathMetricRangeNV) Class() binary.Class {
	return (*binaryClassGlGetPathMetricRangeNV)(nil)
}
func doEncodeGlGetPathMetricRangeNV(e binary.Encoder, o *GlGetPathMetricRangeNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MetricQueryMask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstPathName)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	if err := e.Value(&o.Metrics); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathMetricRangeNV(d binary.Decoder, o *GlGetPathMetricRangeNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MetricQueryMask = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstPathName = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	if err := d.Value(&o.Metrics); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathMetricRangeNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathMetricRangeNV) ID() binary.ID      { return binaryIDGlGetPathMetricRangeNV }
func (*binaryClassGlGetPathMetricRangeNV) New() binary.Object { return &GlGetPathMetricRangeNV{} }
func (*binaryClassGlGetPathMetricRangeNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathMetricRangeNV(e, obj.(*GlGetPathMetricRangeNV))
}
func (*binaryClassGlGetPathMetricRangeNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathMetricRangeNV{}
	return obj, doDecodeGlGetPathMetricRangeNV(d, obj)
}
func (*binaryClassGlGetPathMetricRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathMetricRangeNV(d, obj.(*GlGetPathMetricRangeNV))
}
func (*binaryClassGlGetPathMetricRangeNV) Skip(d binary.Decoder) error {
	return doSkipGlGetPathMetricRangeNV(d)
}
func (*binaryClassGlGetPathMetricRangeNV) Schema() *schema.Class { return schemaGlGetPathMetricRangeNV }

var schemaGlGetPathMetricRangeNV = &schema.Class{
	TypeID:  binaryIDGlGetPathMetricRangeNV,
	Package: "gles",
	Name:    "GlGetPathMetricRangeNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MetricQueryMask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "FirstPathName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Metrics", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathMetricsNV struct{}

func (*GlGetPathMetricsNV) Class() binary.Class {
	return (*binaryClassGlGetPathMetricsNV)(nil)
}
func doEncodeGlGetPathMetricsNV(e binary.Encoder, o *GlGetPathMetricsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MetricQueryMask)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	if err := e.Value(&o.Metrics); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathMetricsNV(d binary.Decoder, o *GlGetPathMetricsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MetricQueryMask = GLbitfield(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	if err := d.Value(&o.Metrics); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathMetricsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathMetricsNV) ID() binary.ID      { return binaryIDGlGetPathMetricsNV }
func (*binaryClassGlGetPathMetricsNV) New() binary.Object { return &GlGetPathMetricsNV{} }
func (*binaryClassGlGetPathMetricsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathMetricsNV(e, obj.(*GlGetPathMetricsNV))
}
func (*binaryClassGlGetPathMetricsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathMetricsNV{}
	return obj, doDecodeGlGetPathMetricsNV(d, obj)
}
func (*binaryClassGlGetPathMetricsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathMetricsNV(d, obj.(*GlGetPathMetricsNV))
}
func (*binaryClassGlGetPathMetricsNV) Skip(d binary.Decoder) error { return doSkipGlGetPathMetricsNV(d) }
func (*binaryClassGlGetPathMetricsNV) Schema() *schema.Class       { return schemaGlGetPathMetricsNV }

var schemaGlGetPathMetricsNV = &schema.Class{
	TypeID:  binaryIDGlGetPathMetricsNV,
	Package: "gles",
	Name:    "GlGetPathMetricsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MetricQueryMask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Metrics", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathParameterfvNV struct{}

func (*GlGetPathParameterfvNV) Class() binary.Class {
	return (*binaryClassGlGetPathParameterfvNV)(nil)
}
func doEncodeGlGetPathParameterfvNV(e binary.Encoder, o *GlGetPathParameterfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathParameterfvNV(d binary.Decoder, o *GlGetPathParameterfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathParameterfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathParameterfvNV) ID() binary.ID      { return binaryIDGlGetPathParameterfvNV }
func (*binaryClassGlGetPathParameterfvNV) New() binary.Object { return &GlGetPathParameterfvNV{} }
func (*binaryClassGlGetPathParameterfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathParameterfvNV(e, obj.(*GlGetPathParameterfvNV))
}
func (*binaryClassGlGetPathParameterfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathParameterfvNV{}
	return obj, doDecodeGlGetPathParameterfvNV(d, obj)
}
func (*binaryClassGlGetPathParameterfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathParameterfvNV(d, obj.(*GlGetPathParameterfvNV))
}
func (*binaryClassGlGetPathParameterfvNV) Skip(d binary.Decoder) error {
	return doSkipGlGetPathParameterfvNV(d)
}
func (*binaryClassGlGetPathParameterfvNV) Schema() *schema.Class { return schemaGlGetPathParameterfvNV }

var schemaGlGetPathParameterfvNV = &schema.Class{
	TypeID:  binaryIDGlGetPathParameterfvNV,
	Package: "gles",
	Name:    "GlGetPathParameterfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathParameterivNV struct{}

func (*GlGetPathParameterivNV) Class() binary.Class {
	return (*binaryClassGlGetPathParameterivNV)(nil)
}
func doEncodeGlGetPathParameterivNV(e binary.Encoder, o *GlGetPathParameterivNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathParameterivNV(d binary.Decoder, o *GlGetPathParameterivNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathParameterivNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathParameterivNV) ID() binary.ID      { return binaryIDGlGetPathParameterivNV }
func (*binaryClassGlGetPathParameterivNV) New() binary.Object { return &GlGetPathParameterivNV{} }
func (*binaryClassGlGetPathParameterivNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathParameterivNV(e, obj.(*GlGetPathParameterivNV))
}
func (*binaryClassGlGetPathParameterivNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathParameterivNV{}
	return obj, doDecodeGlGetPathParameterivNV(d, obj)
}
func (*binaryClassGlGetPathParameterivNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathParameterivNV(d, obj.(*GlGetPathParameterivNV))
}
func (*binaryClassGlGetPathParameterivNV) Skip(d binary.Decoder) error {
	return doSkipGlGetPathParameterivNV(d)
}
func (*binaryClassGlGetPathParameterivNV) Schema() *schema.Class { return schemaGlGetPathParameterivNV }

var schemaGlGetPathParameterivNV = &schema.Class{
	TypeID:  binaryIDGlGetPathParameterivNV,
	Package: "gles",
	Name:    "GlGetPathParameterivNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPathSpacingNV struct{}

func (*GlGetPathSpacingNV) Class() binary.Class {
	return (*binaryClassGlGetPathSpacingNV)(nil)
}
func doEncodeGlGetPathSpacingNV(e binary.Encoder, o *GlGetPathSpacingNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathListMode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.AdvanceScale)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.KerningScale)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.ReturnedSpacing); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPathSpacingNV(d binary.Decoder, o *GlGetPathSpacingNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathListMode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.AdvanceScale = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.KerningScale = GLfloat(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.ReturnedSpacing); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPathSpacingNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPathSpacingNV) ID() binary.ID      { return binaryIDGlGetPathSpacingNV }
func (*binaryClassGlGetPathSpacingNV) New() binary.Object { return &GlGetPathSpacingNV{} }
func (*binaryClassGlGetPathSpacingNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPathSpacingNV(e, obj.(*GlGetPathSpacingNV))
}
func (*binaryClassGlGetPathSpacingNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPathSpacingNV{}
	return obj, doDecodeGlGetPathSpacingNV(d, obj)
}
func (*binaryClassGlGetPathSpacingNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPathSpacingNV(d, obj.(*GlGetPathSpacingNV))
}
func (*binaryClassGlGetPathSpacingNV) Skip(d binary.Decoder) error { return doSkipGlGetPathSpacingNV(d) }
func (*binaryClassGlGetPathSpacingNV) Schema() *schema.Class       { return schemaGlGetPathSpacingNV }

var schemaGlGetPathSpacingNV = &schema.Class{
	TypeID:  binaryIDGlGetPathSpacingNV,
	Package: "gles",
	Name:    "GlGetPathSpacingNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "PathListMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "AdvanceScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "KerningScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ReturnedSpacing", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfCounterInfoINTEL struct{}

func (*GlGetPerfCounterInfoINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfCounterInfoINTEL)(nil)
}
func doEncodeGlGetPerfCounterInfoINTEL(e binary.Encoder, o *GlGetPerfCounterInfoINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryId)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CounterId)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CounterNameLength)); err != nil {
		return err
	}
	if err := e.Value(&o.CounterName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CounterDescLength)); err != nil {
		return err
	}
	if err := e.Value(&o.CounterDesc); err != nil {
		return err
	}
	if err := e.Value(&o.CounterOffset); err != nil {
		return err
	}
	if err := e.Value(&o.CounterDataSize); err != nil {
		return err
	}
	if err := e.Value(&o.CounterTypeEnum); err != nil {
		return err
	}
	if err := e.Value(&o.CounterDataTypeEnum); err != nil {
		return err
	}
	if err := e.Value(&o.RawCounterMaxValue); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfCounterInfoINTEL(d binary.Decoder, o *GlGetPerfCounterInfoINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryId = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CounterId = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CounterNameLength = GLuint(obj)
	}
	if err := d.Value(&o.CounterName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CounterDescLength = GLuint(obj)
	}
	if err := d.Value(&o.CounterDesc); err != nil {
		return err
	}
	if err := d.Value(&o.CounterOffset); err != nil {
		return err
	}
	if err := d.Value(&o.CounterDataSize); err != nil {
		return err
	}
	if err := d.Value(&o.CounterTypeEnum); err != nil {
		return err
	}
	if err := d.Value(&o.CounterDataTypeEnum); err != nil {
		return err
	}
	if err := d.Value(&o.RawCounterMaxValue); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfCounterInfoINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfCounterInfoINTEL) ID() binary.ID      { return binaryIDGlGetPerfCounterInfoINTEL }
func (*binaryClassGlGetPerfCounterInfoINTEL) New() binary.Object { return &GlGetPerfCounterInfoINTEL{} }
func (*binaryClassGlGetPerfCounterInfoINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfCounterInfoINTEL(e, obj.(*GlGetPerfCounterInfoINTEL))
}
func (*binaryClassGlGetPerfCounterInfoINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfCounterInfoINTEL{}
	return obj, doDecodeGlGetPerfCounterInfoINTEL(d, obj)
}
func (*binaryClassGlGetPerfCounterInfoINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfCounterInfoINTEL(d, obj.(*GlGetPerfCounterInfoINTEL))
}
func (*binaryClassGlGetPerfCounterInfoINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfCounterInfoINTEL(d)
}
func (*binaryClassGlGetPerfCounterInfoINTEL) Schema() *schema.Class {
	return schemaGlGetPerfCounterInfoINTEL
}

var schemaGlGetPerfCounterInfoINTEL = &schema.Class{
	TypeID:  binaryIDGlGetPerfCounterInfoINTEL,
	Package: "gles",
	Name:    "GlGetPerfCounterInfoINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CounterId", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CounterNameLength", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CounterName", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "CounterDescLength", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CounterDesc", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "CounterOffset", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "CounterDataSize", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "CounterTypeEnum", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "CounterDataTypeEnum", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "RawCounterMaxValue", Type: &schema.Struct{Name: "GLuint64ᵖ", ID: (*GLuint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorCounterDataAMD struct{}

func (*GlGetPerfMonitorCounterDataAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterDataAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterDataAMD(e binary.Encoder, o *GlGetPerfMonitorCounterDataAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Monitor)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DataSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Value(&o.BytesWritten); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorCounterDataAMD(d binary.Decoder, o *GlGetPerfMonitorCounterDataAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Monitor = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DataSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if err := d.Value(&o.BytesWritten); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorCounterDataAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) ID() binary.ID {
	return binaryIDGlGetPerfMonitorCounterDataAMD
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterDataAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorCounterDataAMD(e, obj.(*GlGetPerfMonitorCounterDataAMD))
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorCounterDataAMD{}
	return obj, doDecodeGlGetPerfMonitorCounterDataAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorCounterDataAMD(d, obj.(*GlGetPerfMonitorCounterDataAMD))
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorCounterDataAMD(d)
}
func (*binaryClassGlGetPerfMonitorCounterDataAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorCounterDataAMD
}

var schemaGlGetPerfMonitorCounterDataAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorCounterDataAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorCounterDataAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Monitor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "DataSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "BytesWritten", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorCounterInfoAMD struct{}

func (*GlGetPerfMonitorCounterInfoAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterInfoAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterInfoAMD(e binary.Encoder, o *GlGetPerfMonitorCounterInfoAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Group)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Counter)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorCounterInfoAMD(d binary.Decoder, o *GlGetPerfMonitorCounterInfoAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Group = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Counter = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorCounterInfoAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) ID() binary.ID {
	return binaryIDGlGetPerfMonitorCounterInfoAMD
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterInfoAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorCounterInfoAMD(e, obj.(*GlGetPerfMonitorCounterInfoAMD))
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorCounterInfoAMD{}
	return obj, doDecodeGlGetPerfMonitorCounterInfoAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorCounterInfoAMD(d, obj.(*GlGetPerfMonitorCounterInfoAMD))
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorCounterInfoAMD(d)
}
func (*binaryClassGlGetPerfMonitorCounterInfoAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorCounterInfoAMD
}

var schemaGlGetPerfMonitorCounterInfoAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorCounterInfoAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorCounterInfoAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Group", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Counter", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorCounterStringAMD struct{}

func (*GlGetPerfMonitorCounterStringAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCounterStringAMD)(nil)
}
func doEncodeGlGetPerfMonitorCounterStringAMD(e binary.Encoder, o *GlGetPerfMonitorCounterStringAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Group)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Counter)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.CounterString); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorCounterStringAMD(d binary.Decoder, o *GlGetPerfMonitorCounterStringAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Group = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Counter = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.CounterString); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorCounterStringAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) ID() binary.ID {
	return binaryIDGlGetPerfMonitorCounterStringAMD
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) New() binary.Object {
	return &GlGetPerfMonitorCounterStringAMD{}
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorCounterStringAMD(e, obj.(*GlGetPerfMonitorCounterStringAMD))
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorCounterStringAMD{}
	return obj, doDecodeGlGetPerfMonitorCounterStringAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorCounterStringAMD(d, obj.(*GlGetPerfMonitorCounterStringAMD))
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorCounterStringAMD(d)
}
func (*binaryClassGlGetPerfMonitorCounterStringAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorCounterStringAMD
}

var schemaGlGetPerfMonitorCounterStringAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorCounterStringAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorCounterStringAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Group", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Counter", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "CounterString", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorCountersAMD struct{}

func (*GlGetPerfMonitorCountersAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorCountersAMD)(nil)
}
func doEncodeGlGetPerfMonitorCountersAMD(e binary.Encoder, o *GlGetPerfMonitorCountersAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Group)); err != nil {
		return err
	}
	if err := e.Value(&o.NumCounters); err != nil {
		return err
	}
	if err := e.Value(&o.MaxActiveCounters); err != nil {
		return err
	}
	if err := e.Int32(int32(o.CounterSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Counters); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorCountersAMD(d binary.Decoder, o *GlGetPerfMonitorCountersAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Group = GLuint(obj)
	}
	if err := d.Value(&o.NumCounters); err != nil {
		return err
	}
	if err := d.Value(&o.MaxActiveCounters); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.CounterSize = GLsizei(obj)
	}
	if err := d.Value(&o.Counters); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorCountersAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorCountersAMD) ID() binary.ID {
	return binaryIDGlGetPerfMonitorCountersAMD
}
func (*binaryClassGlGetPerfMonitorCountersAMD) New() binary.Object {
	return &GlGetPerfMonitorCountersAMD{}
}
func (*binaryClassGlGetPerfMonitorCountersAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorCountersAMD(e, obj.(*GlGetPerfMonitorCountersAMD))
}
func (*binaryClassGlGetPerfMonitorCountersAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorCountersAMD{}
	return obj, doDecodeGlGetPerfMonitorCountersAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorCountersAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorCountersAMD(d, obj.(*GlGetPerfMonitorCountersAMD))
}
func (*binaryClassGlGetPerfMonitorCountersAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorCountersAMD(d)
}
func (*binaryClassGlGetPerfMonitorCountersAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorCountersAMD
}

var schemaGlGetPerfMonitorCountersAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorCountersAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorCountersAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Group", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumCounters", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "MaxActiveCounters", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "CounterSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Counters", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorGroupStringAMD struct{}

func (*GlGetPerfMonitorGroupStringAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorGroupStringAMD)(nil)
}
func doEncodeGlGetPerfMonitorGroupStringAMD(e binary.Encoder, o *GlGetPerfMonitorGroupStringAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Group)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.GroupString); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorGroupStringAMD(d binary.Decoder, o *GlGetPerfMonitorGroupStringAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Group = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.GroupString); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorGroupStringAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) ID() binary.ID {
	return binaryIDGlGetPerfMonitorGroupStringAMD
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) New() binary.Object {
	return &GlGetPerfMonitorGroupStringAMD{}
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorGroupStringAMD(e, obj.(*GlGetPerfMonitorGroupStringAMD))
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorGroupStringAMD{}
	return obj, doDecodeGlGetPerfMonitorGroupStringAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorGroupStringAMD(d, obj.(*GlGetPerfMonitorGroupStringAMD))
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorGroupStringAMD(d)
}
func (*binaryClassGlGetPerfMonitorGroupStringAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorGroupStringAMD
}

var schemaGlGetPerfMonitorGroupStringAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorGroupStringAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorGroupStringAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Group", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "GroupString", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfMonitorGroupsAMD struct{}

func (*GlGetPerfMonitorGroupsAMD) Class() binary.Class {
	return (*binaryClassGlGetPerfMonitorGroupsAMD)(nil)
}
func doEncodeGlGetPerfMonitorGroupsAMD(e binary.Encoder, o *GlGetPerfMonitorGroupsAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.NumGroups); err != nil {
		return err
	}
	if err := e.Int32(int32(o.GroupsSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Groups); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfMonitorGroupsAMD(d binary.Decoder, o *GlGetPerfMonitorGroupsAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.NumGroups); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.GroupsSize = GLsizei(obj)
	}
	if err := d.Value(&o.Groups); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfMonitorGroupsAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) ID() binary.ID      { return binaryIDGlGetPerfMonitorGroupsAMD }
func (*binaryClassGlGetPerfMonitorGroupsAMD) New() binary.Object { return &GlGetPerfMonitorGroupsAMD{} }
func (*binaryClassGlGetPerfMonitorGroupsAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfMonitorGroupsAMD(e, obj.(*GlGetPerfMonitorGroupsAMD))
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfMonitorGroupsAMD{}
	return obj, doDecodeGlGetPerfMonitorGroupsAMD(d, obj)
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfMonitorGroupsAMD(d, obj.(*GlGetPerfMonitorGroupsAMD))
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfMonitorGroupsAMD(d)
}
func (*binaryClassGlGetPerfMonitorGroupsAMD) Schema() *schema.Class {
	return schemaGlGetPerfMonitorGroupsAMD
}

var schemaGlGetPerfMonitorGroupsAMD = &schema.Class{
	TypeID:  binaryIDGlGetPerfMonitorGroupsAMD,
	Package: "gles",
	Name:    "GlGetPerfMonitorGroupsAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumGroups", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "GroupsSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Groups", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfQueryDataINTEL struct{}

func (*GlGetPerfQueryDataINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryDataINTEL)(nil)
}
func doEncodeGlGetPerfQueryDataINTEL(e binary.Encoder, o *GlGetPerfQueryDataINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryHandle)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flag)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DataSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	if err := e.Value(&o.BytesWritten); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfQueryDataINTEL(d binary.Decoder, o *GlGetPerfQueryDataINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryHandle = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flag = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DataSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	if err := d.Value(&o.BytesWritten); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfQueryDataINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLvoidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfQueryDataINTEL) ID() binary.ID      { return binaryIDGlGetPerfQueryDataINTEL }
func (*binaryClassGlGetPerfQueryDataINTEL) New() binary.Object { return &GlGetPerfQueryDataINTEL{} }
func (*binaryClassGlGetPerfQueryDataINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfQueryDataINTEL(e, obj.(*GlGetPerfQueryDataINTEL))
}
func (*binaryClassGlGetPerfQueryDataINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfQueryDataINTEL{}
	return obj, doDecodeGlGetPerfQueryDataINTEL(d, obj)
}
func (*binaryClassGlGetPerfQueryDataINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfQueryDataINTEL(d, obj.(*GlGetPerfQueryDataINTEL))
}
func (*binaryClassGlGetPerfQueryDataINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfQueryDataINTEL(d)
}
func (*binaryClassGlGetPerfQueryDataINTEL) Schema() *schema.Class {
	return schemaGlGetPerfQueryDataINTEL
}

var schemaGlGetPerfQueryDataINTEL = &schema.Class{
	TypeID:  binaryIDGlGetPerfQueryDataINTEL,
	Package: "gles",
	Name:    "GlGetPerfQueryDataINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryHandle", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Flag", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "DataSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "GLvoidᵖ", ID: (*GLvoidᵖ)(nil).Class().ID()}},
		{Declared: "BytesWritten", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfQueryIdByNameINTEL struct{}

func (*GlGetPerfQueryIdByNameINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryIdByNameINTEL)(nil)
}
func doEncodeGlGetPerfQueryIdByNameINTEL(e binary.Encoder, o *GlGetPerfQueryIdByNameINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.QueryName); err != nil {
		return err
	}
	if err := e.Value(&o.QueryId); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfQueryIdByNameINTEL(d binary.Decoder, o *GlGetPerfQueryIdByNameINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.QueryName); err != nil {
		return err
	}
	if err := d.Value(&o.QueryId); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfQueryIdByNameINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) ID() binary.ID {
	return binaryIDGlGetPerfQueryIdByNameINTEL
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) New() binary.Object {
	return &GlGetPerfQueryIdByNameINTEL{}
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfQueryIdByNameINTEL(e, obj.(*GlGetPerfQueryIdByNameINTEL))
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfQueryIdByNameINTEL{}
	return obj, doDecodeGlGetPerfQueryIdByNameINTEL(d, obj)
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfQueryIdByNameINTEL(d, obj.(*GlGetPerfQueryIdByNameINTEL))
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfQueryIdByNameINTEL(d)
}
func (*binaryClassGlGetPerfQueryIdByNameINTEL) Schema() *schema.Class {
	return schemaGlGetPerfQueryIdByNameINTEL
}

var schemaGlGetPerfQueryIdByNameINTEL = &schema.Class{
	TypeID:  binaryIDGlGetPerfQueryIdByNameINTEL,
	Package: "gles",
	Name:    "GlGetPerfQueryIdByNameINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryName", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPerfQueryInfoINTEL struct{}

func (*GlGetPerfQueryInfoINTEL) Class() binary.Class {
	return (*binaryClassGlGetPerfQueryInfoINTEL)(nil)
}
func doEncodeGlGetPerfQueryInfoINTEL(e binary.Encoder, o *GlGetPerfQueryInfoINTEL) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryId)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.QueryNameLength)); err != nil {
		return err
	}
	if err := e.Value(&o.QueryName); err != nil {
		return err
	}
	if err := e.Value(&o.DataSize); err != nil {
		return err
	}
	if err := e.Value(&o.NoCounters); err != nil {
		return err
	}
	if err := e.Value(&o.NoInstances); err != nil {
		return err
	}
	if err := e.Value(&o.CapsMask); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPerfQueryInfoINTEL(d binary.Decoder, o *GlGetPerfQueryInfoINTEL) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryId = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.QueryNameLength = GLuint(obj)
	}
	if err := d.Value(&o.QueryName); err != nil {
		return err
	}
	if err := d.Value(&o.DataSize); err != nil {
		return err
	}
	if err := d.Value(&o.NoCounters); err != nil {
		return err
	}
	if err := d.Value(&o.NoInstances); err != nil {
		return err
	}
	if err := d.Value(&o.CapsMask); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPerfQueryInfoINTEL(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPerfQueryInfoINTEL) ID() binary.ID      { return binaryIDGlGetPerfQueryInfoINTEL }
func (*binaryClassGlGetPerfQueryInfoINTEL) New() binary.Object { return &GlGetPerfQueryInfoINTEL{} }
func (*binaryClassGlGetPerfQueryInfoINTEL) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPerfQueryInfoINTEL(e, obj.(*GlGetPerfQueryInfoINTEL))
}
func (*binaryClassGlGetPerfQueryInfoINTEL) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPerfQueryInfoINTEL{}
	return obj, doDecodeGlGetPerfQueryInfoINTEL(d, obj)
}
func (*binaryClassGlGetPerfQueryInfoINTEL) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPerfQueryInfoINTEL(d, obj.(*GlGetPerfQueryInfoINTEL))
}
func (*binaryClassGlGetPerfQueryInfoINTEL) Skip(d binary.Decoder) error {
	return doSkipGlGetPerfQueryInfoINTEL(d)
}
func (*binaryClassGlGetPerfQueryInfoINTEL) Schema() *schema.Class {
	return schemaGlGetPerfQueryInfoINTEL
}

var schemaGlGetPerfQueryInfoINTEL = &schema.Class{
	TypeID:  binaryIDGlGetPerfQueryInfoINTEL,
	Package: "gles",
	Name:    "GlGetPerfQueryInfoINTEL",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "QueryId", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "QueryNameLength", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "QueryName", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
		{Declared: "DataSize", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "NoCounters", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "NoInstances", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
		{Declared: "CapsMask", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetPointervKHR struct{}

func (*GlGetPointervKHR) Class() binary.Class {
	return (*binaryClassGlGetPointervKHR)(nil)
}
func doEncodeGlGetPointervKHR(e binary.Encoder, o *GlGetPointervKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetPointervKHR(d binary.Decoder, o *GlGetPointervKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetPointervKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetPointervKHR) ID() binary.ID      { return binaryIDGlGetPointervKHR }
func (*binaryClassGlGetPointervKHR) New() binary.Object { return &GlGetPointervKHR{} }
func (*binaryClassGlGetPointervKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetPointervKHR(e, obj.(*GlGetPointervKHR))
}
func (*binaryClassGlGetPointervKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetPointervKHR{}
	return obj, doDecodeGlGetPointervKHR(d, obj)
}
func (*binaryClassGlGetPointervKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetPointervKHR(d, obj.(*GlGetPointervKHR))
}
func (*binaryClassGlGetPointervKHR) Skip(d binary.Decoder) error { return doSkipGlGetPointervKHR(d) }
func (*binaryClassGlGetPointervKHR) Schema() *schema.Class       { return schemaGlGetPointervKHR }

var schemaGlGetPointervKHR = &schema.Class{
	TypeID:  binaryIDGlGetPointervKHR,
	Package: "gles",
	Name:    "GlGetPointervKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "Voidᵖᵖ", ID: (*Voidᵖᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramBinary struct{}

func (*GlGetProgramBinary) Class() binary.Class {
	return (*binaryClassGlGetProgramBinary)(nil)
}
func doEncodeGlGetProgramBinary(e binary.Encoder, o *GlGetProgramBinary) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.BinaryFormat); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramBinary(d binary.Decoder, o *GlGetProgramBinary) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.BinaryFormat); err != nil {
		return err
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramBinary(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramBinary) ID() binary.ID      { return binaryIDGlGetProgramBinary }
func (*binaryClassGlGetProgramBinary) New() binary.Object { return &GlGetProgramBinary{} }
func (*binaryClassGlGetProgramBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramBinary(e, obj.(*GlGetProgramBinary))
}
func (*binaryClassGlGetProgramBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramBinary{}
	return obj, doDecodeGlGetProgramBinary(d, obj)
}
func (*binaryClassGlGetProgramBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramBinary(d, obj.(*GlGetProgramBinary))
}
func (*binaryClassGlGetProgramBinary) Skip(d binary.Decoder) error { return doSkipGlGetProgramBinary(d) }
func (*binaryClassGlGetProgramBinary) Schema() *schema.Class       { return schemaGlGetProgramBinary }

var schemaGlGetProgramBinary = &schema.Class{
	TypeID:  binaryIDGlGetProgramBinary,
	Package: "gles",
	Name:    "GlGetProgramBinary",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "BinaryFormat", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Binary", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramBinaryOES struct{}

func (*GlGetProgramBinaryOES) Class() binary.Class {
	return (*binaryClassGlGetProgramBinaryOES)(nil)
}
func doEncodeGlGetProgramBinaryOES(e binary.Encoder, o *GlGetProgramBinaryOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferSize)); err != nil {
		return err
	}
	if err := e.Value(&o.BytesWritten); err != nil {
		return err
	}
	if err := e.Value(&o.BinaryFormat); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramBinaryOES(d binary.Decoder, o *GlGetProgramBinaryOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferSize = GLsizei(obj)
	}
	if err := d.Value(&o.BytesWritten); err != nil {
		return err
	}
	if err := d.Value(&o.BinaryFormat); err != nil {
		return err
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramBinaryOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramBinaryOES) ID() binary.ID      { return binaryIDGlGetProgramBinaryOES }
func (*binaryClassGlGetProgramBinaryOES) New() binary.Object { return &GlGetProgramBinaryOES{} }
func (*binaryClassGlGetProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramBinaryOES(e, obj.(*GlGetProgramBinaryOES))
}
func (*binaryClassGlGetProgramBinaryOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramBinaryOES{}
	return obj, doDecodeGlGetProgramBinaryOES(d, obj)
}
func (*binaryClassGlGetProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramBinaryOES(d, obj.(*GlGetProgramBinaryOES))
}
func (*binaryClassGlGetProgramBinaryOES) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramBinaryOES(d)
}
func (*binaryClassGlGetProgramBinaryOES) Schema() *schema.Class { return schemaGlGetProgramBinaryOES }

var schemaGlGetProgramBinaryOES = &schema.Class{
	TypeID:  binaryIDGlGetProgramBinaryOES,
	Package: "gles",
	Name:    "GlGetProgramBinaryOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BufferSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "BytesWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "BinaryFormat", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Binary", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramInfoLog struct{}

func (*GlGetProgramInfoLog) Class() binary.Class {
	return (*binaryClassGlGetProgramInfoLog)(nil)
}
func doEncodeGlGetProgramInfoLog(e binary.Encoder, o *GlGetProgramInfoLog) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferLength)); err != nil {
		return err
	}
	if err := e.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := e.Value(&o.Info); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramInfoLog(d binary.Decoder, o *GlGetProgramInfoLog) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferLength = GLsizei(obj)
	}
	if err := d.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := d.Value(&o.Info); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramInfoLog(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramInfoLog) ID() binary.ID      { return binaryIDGlGetProgramInfoLog }
func (*binaryClassGlGetProgramInfoLog) New() binary.Object { return &GlGetProgramInfoLog{} }
func (*binaryClassGlGetProgramInfoLog) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramInfoLog(e, obj.(*GlGetProgramInfoLog))
}
func (*binaryClassGlGetProgramInfoLog) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramInfoLog{}
	return obj, doDecodeGlGetProgramInfoLog(d, obj)
}
func (*binaryClassGlGetProgramInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramInfoLog(d, obj.(*GlGetProgramInfoLog))
}
func (*binaryClassGlGetProgramInfoLog) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramInfoLog(d)
}
func (*binaryClassGlGetProgramInfoLog) Schema() *schema.Class { return schemaGlGetProgramInfoLog }

var schemaGlGetProgramInfoLog = &schema.Class{
	TypeID:  binaryIDGlGetProgramInfoLog,
	Package: "gles",
	Name:    "GlGetProgramInfoLog",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BufferLength", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Info", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramInterfaceiv struct{}

func (*GlGetProgramInterfaceiv) Class() binary.Class {
	return (*binaryClassGlGetProgramInterfaceiv)(nil)
}
func doEncodeGlGetProgramInterfaceiv(e binary.Encoder, o *GlGetProgramInterfaceiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramInterfaceiv(d binary.Decoder, o *GlGetProgramInterfaceiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramInterfaceiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramInterfaceiv) ID() binary.ID      { return binaryIDGlGetProgramInterfaceiv }
func (*binaryClassGlGetProgramInterfaceiv) New() binary.Object { return &GlGetProgramInterfaceiv{} }
func (*binaryClassGlGetProgramInterfaceiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramInterfaceiv(e, obj.(*GlGetProgramInterfaceiv))
}
func (*binaryClassGlGetProgramInterfaceiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramInterfaceiv{}
	return obj, doDecodeGlGetProgramInterfaceiv(d, obj)
}
func (*binaryClassGlGetProgramInterfaceiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramInterfaceiv(d, obj.(*GlGetProgramInterfaceiv))
}
func (*binaryClassGlGetProgramInterfaceiv) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramInterfaceiv(d)
}
func (*binaryClassGlGetProgramInterfaceiv) Schema() *schema.Class {
	return schemaGlGetProgramInterfaceiv
}

var schemaGlGetProgramInterfaceiv = &schema.Class{
	TypeID:  binaryIDGlGetProgramInterfaceiv,
	Package: "gles",
	Name:    "GlGetProgramInterfaceiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramPipelineInfoLog struct{}

func (*GlGetProgramPipelineInfoLog) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineInfoLog)(nil)
}
func doEncodeGlGetProgramPipelineInfoLog(e binary.Encoder, o *GlGetProgramPipelineInfoLog) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramPipelineInfoLog(d binary.Decoder, o *GlGetProgramPipelineInfoLog) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramPipelineInfoLog(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramPipelineInfoLog) ID() binary.ID {
	return binaryIDGlGetProgramPipelineInfoLog
}
func (*binaryClassGlGetProgramPipelineInfoLog) New() binary.Object {
	return &GlGetProgramPipelineInfoLog{}
}
func (*binaryClassGlGetProgramPipelineInfoLog) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramPipelineInfoLog(e, obj.(*GlGetProgramPipelineInfoLog))
}
func (*binaryClassGlGetProgramPipelineInfoLog) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramPipelineInfoLog{}
	return obj, doDecodeGlGetProgramPipelineInfoLog(d, obj)
}
func (*binaryClassGlGetProgramPipelineInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramPipelineInfoLog(d, obj.(*GlGetProgramPipelineInfoLog))
}
func (*binaryClassGlGetProgramPipelineInfoLog) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramPipelineInfoLog(d)
}
func (*binaryClassGlGetProgramPipelineInfoLog) Schema() *schema.Class {
	return schemaGlGetProgramPipelineInfoLog
}

var schemaGlGetProgramPipelineInfoLog = &schema.Class{
	TypeID:  binaryIDGlGetProgramPipelineInfoLog,
	Package: "gles",
	Name:    "GlGetProgramPipelineInfoLog",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "InfoLog", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramPipelineInfoLogEXT struct{}

func (*GlGetProgramPipelineInfoLogEXT) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineInfoLogEXT)(nil)
}
func doEncodeGlGetProgramPipelineInfoLogEXT(e binary.Encoder, o *GlGetProgramPipelineInfoLogEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramPipelineInfoLogEXT(d binary.Decoder, o *GlGetProgramPipelineInfoLogEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.InfoLog); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramPipelineInfoLogEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) ID() binary.ID {
	return binaryIDGlGetProgramPipelineInfoLogEXT
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) New() binary.Object {
	return &GlGetProgramPipelineInfoLogEXT{}
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramPipelineInfoLogEXT(e, obj.(*GlGetProgramPipelineInfoLogEXT))
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramPipelineInfoLogEXT{}
	return obj, doDecodeGlGetProgramPipelineInfoLogEXT(d, obj)
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramPipelineInfoLogEXT(d, obj.(*GlGetProgramPipelineInfoLogEXT))
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramPipelineInfoLogEXT(d)
}
func (*binaryClassGlGetProgramPipelineInfoLogEXT) Schema() *schema.Class {
	return schemaGlGetProgramPipelineInfoLogEXT
}

var schemaGlGetProgramPipelineInfoLogEXT = &schema.Class{
	TypeID:  binaryIDGlGetProgramPipelineInfoLogEXT,
	Package: "gles",
	Name:    "GlGetProgramPipelineInfoLogEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "InfoLog", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramPipelineiv struct{}

func (*GlGetProgramPipelineiv) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineiv)(nil)
}
func doEncodeGlGetProgramPipelineiv(e binary.Encoder, o *GlGetProgramPipelineiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramPipelineiv(d binary.Decoder, o *GlGetProgramPipelineiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramPipelineiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramPipelineiv) ID() binary.ID      { return binaryIDGlGetProgramPipelineiv }
func (*binaryClassGlGetProgramPipelineiv) New() binary.Object { return &GlGetProgramPipelineiv{} }
func (*binaryClassGlGetProgramPipelineiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramPipelineiv(e, obj.(*GlGetProgramPipelineiv))
}
func (*binaryClassGlGetProgramPipelineiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramPipelineiv{}
	return obj, doDecodeGlGetProgramPipelineiv(d, obj)
}
func (*binaryClassGlGetProgramPipelineiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramPipelineiv(d, obj.(*GlGetProgramPipelineiv))
}
func (*binaryClassGlGetProgramPipelineiv) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramPipelineiv(d)
}
func (*binaryClassGlGetProgramPipelineiv) Schema() *schema.Class { return schemaGlGetProgramPipelineiv }

var schemaGlGetProgramPipelineiv = &schema.Class{
	TypeID:  binaryIDGlGetProgramPipelineiv,
	Package: "gles",
	Name:    "GlGetProgramPipelineiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramPipelineivEXT struct{}

func (*GlGetProgramPipelineivEXT) Class() binary.Class {
	return (*binaryClassGlGetProgramPipelineivEXT)(nil)
}
func doEncodeGlGetProgramPipelineivEXT(e binary.Encoder, o *GlGetProgramPipelineivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramPipelineivEXT(d binary.Decoder, o *GlGetProgramPipelineivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramPipelineivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramPipelineivEXT) ID() binary.ID      { return binaryIDGlGetProgramPipelineivEXT }
func (*binaryClassGlGetProgramPipelineivEXT) New() binary.Object { return &GlGetProgramPipelineivEXT{} }
func (*binaryClassGlGetProgramPipelineivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramPipelineivEXT(e, obj.(*GlGetProgramPipelineivEXT))
}
func (*binaryClassGlGetProgramPipelineivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramPipelineivEXT{}
	return obj, doDecodeGlGetProgramPipelineivEXT(d, obj)
}
func (*binaryClassGlGetProgramPipelineivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramPipelineivEXT(d, obj.(*GlGetProgramPipelineivEXT))
}
func (*binaryClassGlGetProgramPipelineivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramPipelineivEXT(d)
}
func (*binaryClassGlGetProgramPipelineivEXT) Schema() *schema.Class {
	return schemaGlGetProgramPipelineivEXT
}

var schemaGlGetProgramPipelineivEXT = &schema.Class{
	TypeID:  binaryIDGlGetProgramPipelineivEXT,
	Package: "gles",
	Name:    "GlGetProgramPipelineivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramResourceIndex struct{}

func (*GlGetProgramResourceIndex) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceIndex)(nil)
}
func doEncodeGlGetProgramResourceIndex(e binary.Encoder, o *GlGetProgramResourceIndex) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramResourceIndex(d binary.Decoder, o *GlGetProgramResourceIndex) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLuint(obj)
	}
	return nil
}
func doSkipGlGetProgramResourceIndex(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramResourceIndex) ID() binary.ID      { return binaryIDGlGetProgramResourceIndex }
func (*binaryClassGlGetProgramResourceIndex) New() binary.Object { return &GlGetProgramResourceIndex{} }
func (*binaryClassGlGetProgramResourceIndex) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramResourceIndex(e, obj.(*GlGetProgramResourceIndex))
}
func (*binaryClassGlGetProgramResourceIndex) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramResourceIndex{}
	return obj, doDecodeGlGetProgramResourceIndex(d, obj)
}
func (*binaryClassGlGetProgramResourceIndex) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramResourceIndex(d, obj.(*GlGetProgramResourceIndex))
}
func (*binaryClassGlGetProgramResourceIndex) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramResourceIndex(d)
}
func (*binaryClassGlGetProgramResourceIndex) Schema() *schema.Class {
	return schemaGlGetProgramResourceIndex
}

var schemaGlGetProgramResourceIndex = &schema.Class{
	TypeID:  binaryIDGlGetProgramResourceIndex,
	Package: "gles",
	Name:    "GlGetProgramResourceIndex",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlGetProgramResourceLocation struct{}

func (*GlGetProgramResourceLocation) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceLocation)(nil)
}
func doEncodeGlGetProgramResourceLocation(e binary.Encoder, o *GlGetProgramResourceLocation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramResourceLocation(d binary.Decoder, o *GlGetProgramResourceLocation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Result = GLint(obj)
	}
	return nil
}
func doSkipGlGetProgramResourceLocation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramResourceLocation) ID() binary.ID {
	return binaryIDGlGetProgramResourceLocation
}
func (*binaryClassGlGetProgramResourceLocation) New() binary.Object {
	return &GlGetProgramResourceLocation{}
}
func (*binaryClassGlGetProgramResourceLocation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramResourceLocation(e, obj.(*GlGetProgramResourceLocation))
}
func (*binaryClassGlGetProgramResourceLocation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramResourceLocation{}
	return obj, doDecodeGlGetProgramResourceLocation(d, obj)
}
func (*binaryClassGlGetProgramResourceLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramResourceLocation(d, obj.(*GlGetProgramResourceLocation))
}
func (*binaryClassGlGetProgramResourceLocation) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramResourceLocation(d)
}
func (*binaryClassGlGetProgramResourceLocation) Schema() *schema.Class {
	return schemaGlGetProgramResourceLocation
}

var schemaGlGetProgramResourceLocation = &schema.Class{
	TypeID:  binaryIDGlGetProgramResourceLocation,
	Package: "gles",
	Name:    "GlGetProgramResourceLocation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlGetProgramResourceName struct{}

func (*GlGetProgramResourceName) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceName)(nil)
}
func doEncodeGlGetProgramResourceName(e binary.Encoder, o *GlGetProgramResourceName) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramResourceName(d binary.Decoder, o *GlGetProgramResourceName) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramResourceName(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramResourceName) ID() binary.ID      { return binaryIDGlGetProgramResourceName }
func (*binaryClassGlGetProgramResourceName) New() binary.Object { return &GlGetProgramResourceName{} }
func (*binaryClassGlGetProgramResourceName) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramResourceName(e, obj.(*GlGetProgramResourceName))
}
func (*binaryClassGlGetProgramResourceName) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramResourceName{}
	return obj, doDecodeGlGetProgramResourceName(d, obj)
}
func (*binaryClassGlGetProgramResourceName) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramResourceName(d, obj.(*GlGetProgramResourceName))
}
func (*binaryClassGlGetProgramResourceName) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramResourceName(d)
}
func (*binaryClassGlGetProgramResourceName) Schema() *schema.Class {
	return schemaGlGetProgramResourceName
}

var schemaGlGetProgramResourceName = &schema.Class{
	TypeID:  binaryIDGlGetProgramResourceName,
	Package: "gles",
	Name:    "GlGetProgramResourceName",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramResourcefvNV struct{}

func (*GlGetProgramResourcefvNV) Class() binary.Class {
	return (*binaryClassGlGetProgramResourcefvNV)(nil)
}
func doEncodeGlGetProgramResourcefvNV(e binary.Encoder, o *GlGetProgramResourcefvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.PropCount)); err != nil {
		return err
	}
	if err := e.Value(&o.Props); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramResourcefvNV(d binary.Decoder, o *GlGetProgramResourcefvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.PropCount = GLsizei(obj)
	}
	if err := d.Value(&o.Props); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramResourcefvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramResourcefvNV) ID() binary.ID      { return binaryIDGlGetProgramResourcefvNV }
func (*binaryClassGlGetProgramResourcefvNV) New() binary.Object { return &GlGetProgramResourcefvNV{} }
func (*binaryClassGlGetProgramResourcefvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramResourcefvNV(e, obj.(*GlGetProgramResourcefvNV))
}
func (*binaryClassGlGetProgramResourcefvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramResourcefvNV{}
	return obj, doDecodeGlGetProgramResourcefvNV(d, obj)
}
func (*binaryClassGlGetProgramResourcefvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramResourcefvNV(d, obj.(*GlGetProgramResourcefvNV))
}
func (*binaryClassGlGetProgramResourcefvNV) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramResourcefvNV(d)
}
func (*binaryClassGlGetProgramResourcefvNV) Schema() *schema.Class {
	return schemaGlGetProgramResourcefvNV
}

var schemaGlGetProgramResourcefvNV = &schema.Class{
	TypeID:  binaryIDGlGetProgramResourcefvNV,
	Package: "gles",
	Name:    "GlGetProgramResourcefvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "PropCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Props", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramResourceiv struct{}

func (*GlGetProgramResourceiv) Class() binary.Class {
	return (*binaryClassGlGetProgramResourceiv)(nil)
}
func doEncodeGlGetProgramResourceiv(e binary.Encoder, o *GlGetProgramResourceiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ProgramInterface)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.PropCount)); err != nil {
		return err
	}
	if err := e.Value(&o.Props); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramResourceiv(d binary.Decoder, o *GlGetProgramResourceiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ProgramInterface = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.PropCount = GLsizei(obj)
	}
	if err := d.Value(&o.Props); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramResourceiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramResourceiv) ID() binary.ID      { return binaryIDGlGetProgramResourceiv }
func (*binaryClassGlGetProgramResourceiv) New() binary.Object { return &GlGetProgramResourceiv{} }
func (*binaryClassGlGetProgramResourceiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramResourceiv(e, obj.(*GlGetProgramResourceiv))
}
func (*binaryClassGlGetProgramResourceiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramResourceiv{}
	return obj, doDecodeGlGetProgramResourceiv(d, obj)
}
func (*binaryClassGlGetProgramResourceiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramResourceiv(d, obj.(*GlGetProgramResourceiv))
}
func (*binaryClassGlGetProgramResourceiv) Skip(d binary.Decoder) error {
	return doSkipGlGetProgramResourceiv(d)
}
func (*binaryClassGlGetProgramResourceiv) Schema() *schema.Class { return schemaGlGetProgramResourceiv }

var schemaGlGetProgramResourceiv = &schema.Class{
	TypeID:  binaryIDGlGetProgramResourceiv,
	Package: "gles",
	Name:    "GlGetProgramResourceiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "ProgramInterface", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "PropCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Props", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetProgramiv struct{}

func (*GlGetProgramiv) Class() binary.Class {
	return (*binaryClassGlGetProgramiv)(nil)
}
func doEncodeGlGetProgramiv(e binary.Encoder, o *GlGetProgramiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetProgramiv(d binary.Decoder, o *GlGetProgramiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetProgramiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetProgramiv) ID() binary.ID      { return binaryIDGlGetProgramiv }
func (*binaryClassGlGetProgramiv) New() binary.Object { return &GlGetProgramiv{} }
func (*binaryClassGlGetProgramiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetProgramiv(e, obj.(*GlGetProgramiv))
}
func (*binaryClassGlGetProgramiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetProgramiv{}
	return obj, doDecodeGlGetProgramiv(d, obj)
}
func (*binaryClassGlGetProgramiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetProgramiv(d, obj.(*GlGetProgramiv))
}
func (*binaryClassGlGetProgramiv) Skip(d binary.Decoder) error { return doSkipGlGetProgramiv(d) }
func (*binaryClassGlGetProgramiv) Schema() *schema.Class       { return schemaGlGetProgramiv }

var schemaGlGetProgramiv = &schema.Class{
	TypeID:  binaryIDGlGetProgramiv,
	Package: "gles",
	Name:    "GlGetProgramiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassS64ᵖ struct{}

func (*S64ᵖ) Class() binary.Class {
	return (*binaryClassS64ᵖ)(nil)
}
func doEncodeS64ᵖ(e binary.Encoder, o *S64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeS64ᵖ(d binary.Decoder, o *S64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipS64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS64ᵖ) ID() binary.ID      { return binaryIDS64ᵖ }
func (*binaryClassS64ᵖ) New() binary.Object { return &S64ᵖ{} }
func (*binaryClassS64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS64ᵖ(e, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S64ᵖ{}
	return obj, doDecodeS64ᵖ(d, obj)
}
func (*binaryClassS64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS64ᵖ(d, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Skip(d binary.Decoder) error { return doSkipS64ᵖ(d) }
func (*binaryClassS64ᵖ) Schema() *schema.Class       { return schemaS64ᵖ }

var schemaS64ᵖ = &schema.Class{
	TypeID:  binaryIDS64ᵖ,
	Package: "gles",
	Name:    "S64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjecti64v struct{}

func (*GlGetQueryObjecti64v) Class() binary.Class {
	return (*binaryClassGlGetQueryObjecti64v)(nil)
}
func doEncodeGlGetQueryObjecti64v(e binary.Encoder, o *GlGetQueryObjecti64v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjecti64v(d binary.Decoder, o *GlGetQueryObjecti64v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjecti64v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*S64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjecti64v) ID() binary.ID      { return binaryIDGlGetQueryObjecti64v }
func (*binaryClassGlGetQueryObjecti64v) New() binary.Object { return &GlGetQueryObjecti64v{} }
func (*binaryClassGlGetQueryObjecti64v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjecti64v(e, obj.(*GlGetQueryObjecti64v))
}
func (*binaryClassGlGetQueryObjecti64v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjecti64v{}
	return obj, doDecodeGlGetQueryObjecti64v(d, obj)
}
func (*binaryClassGlGetQueryObjecti64v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjecti64v(d, obj.(*GlGetQueryObjecti64v))
}
func (*binaryClassGlGetQueryObjecti64v) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjecti64v(d)
}
func (*binaryClassGlGetQueryObjecti64v) Schema() *schema.Class { return schemaGlGetQueryObjecti64v }

var schemaGlGetQueryObjecti64v = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjecti64v,
	Package: "gles",
	Name:    "GlGetQueryObjecti64v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "S64ᵖ", ID: (*S64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjecti64vEXT struct{}

func (*GlGetQueryObjecti64vEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjecti64vEXT)(nil)
}
func doEncodeGlGetQueryObjecti64vEXT(e binary.Encoder, o *GlGetQueryObjecti64vEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjecti64vEXT(d binary.Decoder, o *GlGetQueryObjecti64vEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjecti64vEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjecti64vEXT) ID() binary.ID      { return binaryIDGlGetQueryObjecti64vEXT }
func (*binaryClassGlGetQueryObjecti64vEXT) New() binary.Object { return &GlGetQueryObjecti64vEXT{} }
func (*binaryClassGlGetQueryObjecti64vEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjecti64vEXT(e, obj.(*GlGetQueryObjecti64vEXT))
}
func (*binaryClassGlGetQueryObjecti64vEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjecti64vEXT{}
	return obj, doDecodeGlGetQueryObjecti64vEXT(d, obj)
}
func (*binaryClassGlGetQueryObjecti64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjecti64vEXT(d, obj.(*GlGetQueryObjecti64vEXT))
}
func (*binaryClassGlGetQueryObjecti64vEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjecti64vEXT(d)
}
func (*binaryClassGlGetQueryObjecti64vEXT) Schema() *schema.Class {
	return schemaGlGetQueryObjecti64vEXT
}

var schemaGlGetQueryObjecti64vEXT = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjecti64vEXT,
	Package: "gles",
	Name:    "GlGetQueryObjecti64vEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLint64ᵖ", ID: (*GLint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjectivEXT struct{}

func (*GlGetQueryObjectivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectivEXT)(nil)
}
func doEncodeGlGetQueryObjectivEXT(e binary.Encoder, o *GlGetQueryObjectivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjectivEXT(d binary.Decoder, o *GlGetQueryObjectivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjectivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjectivEXT) ID() binary.ID      { return binaryIDGlGetQueryObjectivEXT }
func (*binaryClassGlGetQueryObjectivEXT) New() binary.Object { return &GlGetQueryObjectivEXT{} }
func (*binaryClassGlGetQueryObjectivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjectivEXT(e, obj.(*GlGetQueryObjectivEXT))
}
func (*binaryClassGlGetQueryObjectivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjectivEXT{}
	return obj, doDecodeGlGetQueryObjectivEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjectivEXT(d, obj.(*GlGetQueryObjectivEXT))
}
func (*binaryClassGlGetQueryObjectivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjectivEXT(d)
}
func (*binaryClassGlGetQueryObjectivEXT) Schema() *schema.Class { return schemaGlGetQueryObjectivEXT }

var schemaGlGetQueryObjectivEXT = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjectivEXT,
	Package: "gles",
	Name:    "GlGetQueryObjectivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassU64ᵖ struct{}

func (*U64ᵖ) Class() binary.Class {
	return (*binaryClassU64ᵖ)(nil)
}
func doEncodeU64ᵖ(e binary.Encoder, o *U64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU64ᵖ(d binary.Decoder, o *U64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU64ᵖ) ID() binary.ID      { return binaryIDU64ᵖ }
func (*binaryClassU64ᵖ) New() binary.Object { return &U64ᵖ{} }
func (*binaryClassU64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU64ᵖ(e, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U64ᵖ{}
	return obj, doDecodeU64ᵖ(d, obj)
}
func (*binaryClassU64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU64ᵖ(d, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Skip(d binary.Decoder) error { return doSkipU64ᵖ(d) }
func (*binaryClassU64ᵖ) Schema() *schema.Class       { return schemaU64ᵖ }

var schemaU64ᵖ = &schema.Class{
	TypeID:  binaryIDU64ᵖ,
	Package: "gles",
	Name:    "U64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjectui64v struct{}

func (*GlGetQueryObjectui64v) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectui64v)(nil)
}
func doEncodeGlGetQueryObjectui64v(e binary.Encoder, o *GlGetQueryObjectui64v) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjectui64v(d binary.Decoder, o *GlGetQueryObjectui64v) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjectui64v(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*U64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjectui64v) ID() binary.ID      { return binaryIDGlGetQueryObjectui64v }
func (*binaryClassGlGetQueryObjectui64v) New() binary.Object { return &GlGetQueryObjectui64v{} }
func (*binaryClassGlGetQueryObjectui64v) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjectui64v(e, obj.(*GlGetQueryObjectui64v))
}
func (*binaryClassGlGetQueryObjectui64v) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjectui64v{}
	return obj, doDecodeGlGetQueryObjectui64v(d, obj)
}
func (*binaryClassGlGetQueryObjectui64v) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjectui64v(d, obj.(*GlGetQueryObjectui64v))
}
func (*binaryClassGlGetQueryObjectui64v) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjectui64v(d)
}
func (*binaryClassGlGetQueryObjectui64v) Schema() *schema.Class { return schemaGlGetQueryObjectui64v }

var schemaGlGetQueryObjectui64v = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjectui64v,
	Package: "gles",
	Name:    "GlGetQueryObjectui64v",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "U64ᵖ", ID: (*U64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjectui64vEXT struct{}

func (*GlGetQueryObjectui64vEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectui64vEXT)(nil)
}
func doEncodeGlGetQueryObjectui64vEXT(e binary.Encoder, o *GlGetQueryObjectui64vEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjectui64vEXT(d binary.Decoder, o *GlGetQueryObjectui64vEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjectui64vEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuint64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjectui64vEXT) ID() binary.ID      { return binaryIDGlGetQueryObjectui64vEXT }
func (*binaryClassGlGetQueryObjectui64vEXT) New() binary.Object { return &GlGetQueryObjectui64vEXT{} }
func (*binaryClassGlGetQueryObjectui64vEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjectui64vEXT(e, obj.(*GlGetQueryObjectui64vEXT))
}
func (*binaryClassGlGetQueryObjectui64vEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjectui64vEXT{}
	return obj, doDecodeGlGetQueryObjectui64vEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectui64vEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjectui64vEXT(d, obj.(*GlGetQueryObjectui64vEXT))
}
func (*binaryClassGlGetQueryObjectui64vEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjectui64vEXT(d)
}
func (*binaryClassGlGetQueryObjectui64vEXT) Schema() *schema.Class {
	return schemaGlGetQueryObjectui64vEXT
}

var schemaGlGetQueryObjectui64vEXT = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjectui64vEXT,
	Package: "gles",
	Name:    "GlGetQueryObjectui64vEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuint64ᵖ", ID: (*GLuint64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjectuiv struct{}

func (*GlGetQueryObjectuiv) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectuiv)(nil)
}
func doEncodeGlGetQueryObjectuiv(e binary.Encoder, o *GlGetQueryObjectuiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjectuiv(d binary.Decoder, o *GlGetQueryObjectuiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjectuiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjectuiv) ID() binary.ID      { return binaryIDGlGetQueryObjectuiv }
func (*binaryClassGlGetQueryObjectuiv) New() binary.Object { return &GlGetQueryObjectuiv{} }
func (*binaryClassGlGetQueryObjectuiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjectuiv(e, obj.(*GlGetQueryObjectuiv))
}
func (*binaryClassGlGetQueryObjectuiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjectuiv{}
	return obj, doDecodeGlGetQueryObjectuiv(d, obj)
}
func (*binaryClassGlGetQueryObjectuiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjectuiv(d, obj.(*GlGetQueryObjectuiv))
}
func (*binaryClassGlGetQueryObjectuiv) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjectuiv(d)
}
func (*binaryClassGlGetQueryObjectuiv) Schema() *schema.Class { return schemaGlGetQueryObjectuiv }

var schemaGlGetQueryObjectuiv = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjectuiv,
	Package: "gles",
	Name:    "GlGetQueryObjectuiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryObjectuivEXT struct{}

func (*GlGetQueryObjectuivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryObjectuivEXT)(nil)
}
func doEncodeGlGetQueryObjectuivEXT(e binary.Encoder, o *GlGetQueryObjectuivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryObjectuivEXT(d binary.Decoder, o *GlGetQueryObjectuivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryObjectuivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryObjectuivEXT) ID() binary.ID      { return binaryIDGlGetQueryObjectuivEXT }
func (*binaryClassGlGetQueryObjectuivEXT) New() binary.Object { return &GlGetQueryObjectuivEXT{} }
func (*binaryClassGlGetQueryObjectuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryObjectuivEXT(e, obj.(*GlGetQueryObjectuivEXT))
}
func (*binaryClassGlGetQueryObjectuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryObjectuivEXT{}
	return obj, doDecodeGlGetQueryObjectuivEXT(d, obj)
}
func (*binaryClassGlGetQueryObjectuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryObjectuivEXT(d, obj.(*GlGetQueryObjectuivEXT))
}
func (*binaryClassGlGetQueryObjectuivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetQueryObjectuivEXT(d)
}
func (*binaryClassGlGetQueryObjectuivEXT) Schema() *schema.Class { return schemaGlGetQueryObjectuivEXT }

var schemaGlGetQueryObjectuivEXT = &schema.Class{
	TypeID:  binaryIDGlGetQueryObjectuivEXT,
	Package: "gles",
	Name:    "GlGetQueryObjectuivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryiv struct{}

func (*GlGetQueryiv) Class() binary.Class {
	return (*binaryClassGlGetQueryiv)(nil)
}
func doEncodeGlGetQueryiv(e binary.Encoder, o *GlGetQueryiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryiv(d binary.Decoder, o *GlGetQueryiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryiv) ID() binary.ID      { return binaryIDGlGetQueryiv }
func (*binaryClassGlGetQueryiv) New() binary.Object { return &GlGetQueryiv{} }
func (*binaryClassGlGetQueryiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryiv(e, obj.(*GlGetQueryiv))
}
func (*binaryClassGlGetQueryiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryiv{}
	return obj, doDecodeGlGetQueryiv(d, obj)
}
func (*binaryClassGlGetQueryiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryiv(d, obj.(*GlGetQueryiv))
}
func (*binaryClassGlGetQueryiv) Skip(d binary.Decoder) error { return doSkipGlGetQueryiv(d) }
func (*binaryClassGlGetQueryiv) Schema() *schema.Class       { return schemaGlGetQueryiv }

var schemaGlGetQueryiv = &schema.Class{
	TypeID:  binaryIDGlGetQueryiv,
	Package: "gles",
	Name:    "GlGetQueryiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetQueryivEXT struct{}

func (*GlGetQueryivEXT) Class() binary.Class {
	return (*binaryClassGlGetQueryivEXT)(nil)
}
func doEncodeGlGetQueryivEXT(e binary.Encoder, o *GlGetQueryivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetQueryivEXT(d binary.Decoder, o *GlGetQueryivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetQueryivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetQueryivEXT) ID() binary.ID      { return binaryIDGlGetQueryivEXT }
func (*binaryClassGlGetQueryivEXT) New() binary.Object { return &GlGetQueryivEXT{} }
func (*binaryClassGlGetQueryivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetQueryivEXT(e, obj.(*GlGetQueryivEXT))
}
func (*binaryClassGlGetQueryivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetQueryivEXT{}
	return obj, doDecodeGlGetQueryivEXT(d, obj)
}
func (*binaryClassGlGetQueryivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetQueryivEXT(d, obj.(*GlGetQueryivEXT))
}
func (*binaryClassGlGetQueryivEXT) Skip(d binary.Decoder) error { return doSkipGlGetQueryivEXT(d) }
func (*binaryClassGlGetQueryivEXT) Schema() *schema.Class       { return schemaGlGetQueryivEXT }

var schemaGlGetQueryivEXT = &schema.Class{
	TypeID:  binaryIDGlGetQueryivEXT,
	Package: "gles",
	Name:    "GlGetQueryivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetRenderbufferParameteriv struct{}

func (*GlGetRenderbufferParameteriv) Class() binary.Class {
	return (*binaryClassGlGetRenderbufferParameteriv)(nil)
}
func doEncodeGlGetRenderbufferParameteriv(e binary.Encoder, o *GlGetRenderbufferParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetRenderbufferParameteriv(d binary.Decoder, o *GlGetRenderbufferParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetRenderbufferParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetRenderbufferParameteriv) ID() binary.ID {
	return binaryIDGlGetRenderbufferParameteriv
}
func (*binaryClassGlGetRenderbufferParameteriv) New() binary.Object {
	return &GlGetRenderbufferParameteriv{}
}
func (*binaryClassGlGetRenderbufferParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetRenderbufferParameteriv(e, obj.(*GlGetRenderbufferParameteriv))
}
func (*binaryClassGlGetRenderbufferParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetRenderbufferParameteriv{}
	return obj, doDecodeGlGetRenderbufferParameteriv(d, obj)
}
func (*binaryClassGlGetRenderbufferParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetRenderbufferParameteriv(d, obj.(*GlGetRenderbufferParameteriv))
}
func (*binaryClassGlGetRenderbufferParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetRenderbufferParameteriv(d)
}
func (*binaryClassGlGetRenderbufferParameteriv) Schema() *schema.Class {
	return schemaGlGetRenderbufferParameteriv
}

var schemaGlGetRenderbufferParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetRenderbufferParameteriv,
	Package: "gles",
	Name:    "GlGetRenderbufferParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameterIivEXT struct{}

func (*GlGetSamplerParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIivEXT)(nil)
}
func doEncodeGlGetSamplerParameterIivEXT(e binary.Encoder, o *GlGetSamplerParameterIivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameterIivEXT(d binary.Decoder, o *GlGetSamplerParameterIivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameterIivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameterIivEXT) ID() binary.ID {
	return binaryIDGlGetSamplerParameterIivEXT
}
func (*binaryClassGlGetSamplerParameterIivEXT) New() binary.Object {
	return &GlGetSamplerParameterIivEXT{}
}
func (*binaryClassGlGetSamplerParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameterIivEXT(e, obj.(*GlGetSamplerParameterIivEXT))
}
func (*binaryClassGlGetSamplerParameterIivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameterIivEXT{}
	return obj, doDecodeGlGetSamplerParameterIivEXT(d, obj)
}
func (*binaryClassGlGetSamplerParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameterIivEXT(d, obj.(*GlGetSamplerParameterIivEXT))
}
func (*binaryClassGlGetSamplerParameterIivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameterIivEXT(d)
}
func (*binaryClassGlGetSamplerParameterIivEXT) Schema() *schema.Class {
	return schemaGlGetSamplerParameterIivEXT
}

var schemaGlGetSamplerParameterIivEXT = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameterIivEXT,
	Package: "gles",
	Name:    "GlGetSamplerParameterIivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameterIivOES struct{}

func (*GlGetSamplerParameterIivOES) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIivOES)(nil)
}
func doEncodeGlGetSamplerParameterIivOES(e binary.Encoder, o *GlGetSamplerParameterIivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameterIivOES(d binary.Decoder, o *GlGetSamplerParameterIivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameterIivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameterIivOES) ID() binary.ID {
	return binaryIDGlGetSamplerParameterIivOES
}
func (*binaryClassGlGetSamplerParameterIivOES) New() binary.Object {
	return &GlGetSamplerParameterIivOES{}
}
func (*binaryClassGlGetSamplerParameterIivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameterIivOES(e, obj.(*GlGetSamplerParameterIivOES))
}
func (*binaryClassGlGetSamplerParameterIivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameterIivOES{}
	return obj, doDecodeGlGetSamplerParameterIivOES(d, obj)
}
func (*binaryClassGlGetSamplerParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameterIivOES(d, obj.(*GlGetSamplerParameterIivOES))
}
func (*binaryClassGlGetSamplerParameterIivOES) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameterIivOES(d)
}
func (*binaryClassGlGetSamplerParameterIivOES) Schema() *schema.Class {
	return schemaGlGetSamplerParameterIivOES
}

var schemaGlGetSamplerParameterIivOES = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameterIivOES,
	Package: "gles",
	Name:    "GlGetSamplerParameterIivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameterIuivEXT struct{}

func (*GlGetSamplerParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIuivEXT)(nil)
}
func doEncodeGlGetSamplerParameterIuivEXT(e binary.Encoder, o *GlGetSamplerParameterIuivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameterIuivEXT(d binary.Decoder, o *GlGetSamplerParameterIuivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameterIuivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameterIuivEXT) ID() binary.ID {
	return binaryIDGlGetSamplerParameterIuivEXT
}
func (*binaryClassGlGetSamplerParameterIuivEXT) New() binary.Object {
	return &GlGetSamplerParameterIuivEXT{}
}
func (*binaryClassGlGetSamplerParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameterIuivEXT(e, obj.(*GlGetSamplerParameterIuivEXT))
}
func (*binaryClassGlGetSamplerParameterIuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameterIuivEXT{}
	return obj, doDecodeGlGetSamplerParameterIuivEXT(d, obj)
}
func (*binaryClassGlGetSamplerParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameterIuivEXT(d, obj.(*GlGetSamplerParameterIuivEXT))
}
func (*binaryClassGlGetSamplerParameterIuivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameterIuivEXT(d)
}
func (*binaryClassGlGetSamplerParameterIuivEXT) Schema() *schema.Class {
	return schemaGlGetSamplerParameterIuivEXT
}

var schemaGlGetSamplerParameterIuivEXT = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameterIuivEXT,
	Package: "gles",
	Name:    "GlGetSamplerParameterIuivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameterIuivOES struct{}

func (*GlGetSamplerParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterIuivOES)(nil)
}
func doEncodeGlGetSamplerParameterIuivOES(e binary.Encoder, o *GlGetSamplerParameterIuivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameterIuivOES(d binary.Decoder, o *GlGetSamplerParameterIuivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameterIuivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameterIuivOES) ID() binary.ID {
	return binaryIDGlGetSamplerParameterIuivOES
}
func (*binaryClassGlGetSamplerParameterIuivOES) New() binary.Object {
	return &GlGetSamplerParameterIuivOES{}
}
func (*binaryClassGlGetSamplerParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameterIuivOES(e, obj.(*GlGetSamplerParameterIuivOES))
}
func (*binaryClassGlGetSamplerParameterIuivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameterIuivOES{}
	return obj, doDecodeGlGetSamplerParameterIuivOES(d, obj)
}
func (*binaryClassGlGetSamplerParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameterIuivOES(d, obj.(*GlGetSamplerParameterIuivOES))
}
func (*binaryClassGlGetSamplerParameterIuivOES) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameterIuivOES(d)
}
func (*binaryClassGlGetSamplerParameterIuivOES) Schema() *schema.Class {
	return schemaGlGetSamplerParameterIuivOES
}

var schemaGlGetSamplerParameterIuivOES = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameterIuivOES,
	Package: "gles",
	Name:    "GlGetSamplerParameterIuivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameterfv struct{}

func (*GlGetSamplerParameterfv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameterfv)(nil)
}
func doEncodeGlGetSamplerParameterfv(e binary.Encoder, o *GlGetSamplerParameterfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameterfv(d binary.Decoder, o *GlGetSamplerParameterfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameterfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameterfv) ID() binary.ID      { return binaryIDGlGetSamplerParameterfv }
func (*binaryClassGlGetSamplerParameterfv) New() binary.Object { return &GlGetSamplerParameterfv{} }
func (*binaryClassGlGetSamplerParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameterfv(e, obj.(*GlGetSamplerParameterfv))
}
func (*binaryClassGlGetSamplerParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameterfv{}
	return obj, doDecodeGlGetSamplerParameterfv(d, obj)
}
func (*binaryClassGlGetSamplerParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameterfv(d, obj.(*GlGetSamplerParameterfv))
}
func (*binaryClassGlGetSamplerParameterfv) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameterfv(d)
}
func (*binaryClassGlGetSamplerParameterfv) Schema() *schema.Class {
	return schemaGlGetSamplerParameterfv
}

var schemaGlGetSamplerParameterfv = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameterfv,
	Package: "gles",
	Name:    "GlGetSamplerParameterfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSamplerParameteriv struct{}

func (*GlGetSamplerParameteriv) Class() binary.Class {
	return (*binaryClassGlGetSamplerParameteriv)(nil)
}
func doEncodeGlGetSamplerParameteriv(e binary.Encoder, o *GlGetSamplerParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSamplerParameteriv(d binary.Decoder, o *GlGetSamplerParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSamplerParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSamplerParameteriv) ID() binary.ID      { return binaryIDGlGetSamplerParameteriv }
func (*binaryClassGlGetSamplerParameteriv) New() binary.Object { return &GlGetSamplerParameteriv{} }
func (*binaryClassGlGetSamplerParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSamplerParameteriv(e, obj.(*GlGetSamplerParameteriv))
}
func (*binaryClassGlGetSamplerParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSamplerParameteriv{}
	return obj, doDecodeGlGetSamplerParameteriv(d, obj)
}
func (*binaryClassGlGetSamplerParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSamplerParameteriv(d, obj.(*GlGetSamplerParameteriv))
}
func (*binaryClassGlGetSamplerParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetSamplerParameteriv(d)
}
func (*binaryClassGlGetSamplerParameteriv) Schema() *schema.Class {
	return schemaGlGetSamplerParameteriv
}

var schemaGlGetSamplerParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetSamplerParameteriv,
	Package: "gles",
	Name:    "GlGetSamplerParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetShaderInfoLog struct{}

func (*GlGetShaderInfoLog) Class() binary.Class {
	return (*binaryClassGlGetShaderInfoLog)(nil)
}
func doEncodeGlGetShaderInfoLog(e binary.Encoder, o *GlGetShaderInfoLog) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferLength)); err != nil {
		return err
	}
	if err := e.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := e.Value(&o.Info); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetShaderInfoLog(d binary.Decoder, o *GlGetShaderInfoLog) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferLength = GLsizei(obj)
	}
	if err := d.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := d.Value(&o.Info); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetShaderInfoLog(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetShaderInfoLog) ID() binary.ID      { return binaryIDGlGetShaderInfoLog }
func (*binaryClassGlGetShaderInfoLog) New() binary.Object { return &GlGetShaderInfoLog{} }
func (*binaryClassGlGetShaderInfoLog) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetShaderInfoLog(e, obj.(*GlGetShaderInfoLog))
}
func (*binaryClassGlGetShaderInfoLog) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetShaderInfoLog{}
	return obj, doDecodeGlGetShaderInfoLog(d, obj)
}
func (*binaryClassGlGetShaderInfoLog) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetShaderInfoLog(d, obj.(*GlGetShaderInfoLog))
}
func (*binaryClassGlGetShaderInfoLog) Skip(d binary.Decoder) error { return doSkipGlGetShaderInfoLog(d) }
func (*binaryClassGlGetShaderInfoLog) Schema() *schema.Class       { return schemaGlGetShaderInfoLog }

var schemaGlGetShaderInfoLog = &schema.Class{
	TypeID:  binaryIDGlGetShaderInfoLog,
	Package: "gles",
	Name:    "GlGetShaderInfoLog",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "BufferLength", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Info", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetShaderPrecisionFormat struct{}

func (*GlGetShaderPrecisionFormat) Class() binary.Class {
	return (*binaryClassGlGetShaderPrecisionFormat)(nil)
}
func doEncodeGlGetShaderPrecisionFormat(e binary.Encoder, o *GlGetShaderPrecisionFormat) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ShaderType)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PrecisionType)); err != nil {
		return err
	}
	if err := e.Value(&o.Range); err != nil {
		return err
	}
	if err := e.Value(&o.Precision); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetShaderPrecisionFormat(d binary.Decoder, o *GlGetShaderPrecisionFormat) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ShaderType = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PrecisionType = GLenum(obj)
	}
	if err := d.Value(&o.Range); err != nil {
		return err
	}
	if err := d.Value(&o.Precision); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetShaderPrecisionFormat(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetShaderPrecisionFormat) ID() binary.ID {
	return binaryIDGlGetShaderPrecisionFormat
}
func (*binaryClassGlGetShaderPrecisionFormat) New() binary.Object {
	return &GlGetShaderPrecisionFormat{}
}
func (*binaryClassGlGetShaderPrecisionFormat) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetShaderPrecisionFormat(e, obj.(*GlGetShaderPrecisionFormat))
}
func (*binaryClassGlGetShaderPrecisionFormat) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetShaderPrecisionFormat{}
	return obj, doDecodeGlGetShaderPrecisionFormat(d, obj)
}
func (*binaryClassGlGetShaderPrecisionFormat) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetShaderPrecisionFormat(d, obj.(*GlGetShaderPrecisionFormat))
}
func (*binaryClassGlGetShaderPrecisionFormat) Skip(d binary.Decoder) error {
	return doSkipGlGetShaderPrecisionFormat(d)
}
func (*binaryClassGlGetShaderPrecisionFormat) Schema() *schema.Class {
	return schemaGlGetShaderPrecisionFormat
}

var schemaGlGetShaderPrecisionFormat = &schema.Class{
	TypeID:  binaryIDGlGetShaderPrecisionFormat,
	Package: "gles",
	Name:    "GlGetShaderPrecisionFormat",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ShaderType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "PrecisionType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Range", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
		{Declared: "Precision", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetShaderSource struct{}

func (*GlGetShaderSource) Class() binary.Class {
	return (*binaryClassGlGetShaderSource)(nil)
}
func doEncodeGlGetShaderSource(e binary.Encoder, o *GlGetShaderSource) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufferLength)); err != nil {
		return err
	}
	if err := e.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := e.Value(&o.Source); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetShaderSource(d binary.Decoder, o *GlGetShaderSource) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufferLength = GLsizei(obj)
	}
	if err := d.Value(&o.StringLengthWritten); err != nil {
		return err
	}
	if err := d.Value(&o.Source); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetShaderSource(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetShaderSource) ID() binary.ID      { return binaryIDGlGetShaderSource }
func (*binaryClassGlGetShaderSource) New() binary.Object { return &GlGetShaderSource{} }
func (*binaryClassGlGetShaderSource) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetShaderSource(e, obj.(*GlGetShaderSource))
}
func (*binaryClassGlGetShaderSource) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetShaderSource{}
	return obj, doDecodeGlGetShaderSource(d, obj)
}
func (*binaryClassGlGetShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetShaderSource(d, obj.(*GlGetShaderSource))
}
func (*binaryClassGlGetShaderSource) Skip(d binary.Decoder) error { return doSkipGlGetShaderSource(d) }
func (*binaryClassGlGetShaderSource) Schema() *schema.Class       { return schemaGlGetShaderSource }

var schemaGlGetShaderSource = &schema.Class{
	TypeID:  binaryIDGlGetShaderSource,
	Package: "gles",
	Name:    "GlGetShaderSource",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "BufferLength", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "StringLengthWritten", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetShaderiv struct{}

func (*GlGetShaderiv) Class() binary.Class {
	return (*binaryClassGlGetShaderiv)(nil)
}
func doEncodeGlGetShaderiv(e binary.Encoder, o *GlGetShaderiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetShaderiv(d binary.Decoder, o *GlGetShaderiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetShaderiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetShaderiv) ID() binary.ID      { return binaryIDGlGetShaderiv }
func (*binaryClassGlGetShaderiv) New() binary.Object { return &GlGetShaderiv{} }
func (*binaryClassGlGetShaderiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetShaderiv(e, obj.(*GlGetShaderiv))
}
func (*binaryClassGlGetShaderiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetShaderiv{}
	return obj, doDecodeGlGetShaderiv(d, obj)
}
func (*binaryClassGlGetShaderiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetShaderiv(d, obj.(*GlGetShaderiv))
}
func (*binaryClassGlGetShaderiv) Skip(d binary.Decoder) error { return doSkipGlGetShaderiv(d) }
func (*binaryClassGlGetShaderiv) Schema() *schema.Class       { return schemaGlGetShaderiv }

var schemaGlGetShaderiv = &schema.Class{
	TypeID:  binaryIDGlGetShaderiv,
	Package: "gles",
	Name:    "GlGetShaderiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetString struct{}

func (*GlGetString) Class() binary.Class {
	return (*binaryClassGlGetString)(nil)
}
func doEncodeGlGetString(e binary.Encoder, o *GlGetString) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Param)); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetString(d binary.Decoder, o *GlGetString) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Param = GLenum(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetString(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLubyteᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetString) ID() binary.ID      { return binaryIDGlGetString }
func (*binaryClassGlGetString) New() binary.Object { return &GlGetString{} }
func (*binaryClassGlGetString) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetString(e, obj.(*GlGetString))
}
func (*binaryClassGlGetString) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetString{}
	return obj, doDecodeGlGetString(d, obj)
}
func (*binaryClassGlGetString) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetString(d, obj.(*GlGetString))
}
func (*binaryClassGlGetString) Skip(d binary.Decoder) error { return doSkipGlGetString(d) }
func (*binaryClassGlGetString) Schema() *schema.Class       { return schemaGlGetString }

var schemaGlGetString = &schema.Class{
	TypeID:  binaryIDGlGetString,
	Package: "gles",
	Name:    "GlGetString",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Struct{Name: "GLubyteᶜᵖ", ID: (*GLubyteᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetStringi struct{}

func (*GlGetStringi) Class() binary.Class {
	return (*binaryClassGlGetStringi)(nil)
}
func doEncodeGlGetStringi(e binary.Encoder, o *GlGetStringi) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Name)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetStringi(d binary.Decoder, o *GlGetStringi) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Name = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetStringi(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLubyteᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetStringi) ID() binary.ID      { return binaryIDGlGetStringi }
func (*binaryClassGlGetStringi) New() binary.Object { return &GlGetStringi{} }
func (*binaryClassGlGetStringi) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetStringi(e, obj.(*GlGetStringi))
}
func (*binaryClassGlGetStringi) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetStringi{}
	return obj, doDecodeGlGetStringi(d, obj)
}
func (*binaryClassGlGetStringi) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetStringi(d, obj.(*GlGetStringi))
}
func (*binaryClassGlGetStringi) Skip(d binary.Decoder) error { return doSkipGlGetStringi(d) }
func (*binaryClassGlGetStringi) Schema() *schema.Class       { return schemaGlGetStringi }

var schemaGlGetStringi = &schema.Class{
	TypeID:  binaryIDGlGetStringi,
	Package: "gles",
	Name:    "GlGetStringi",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Struct{Name: "GLubyteᶜᵖ", ID: (*GLubyteᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSynciv struct{}

func (*GlGetSynciv) Class() binary.Class {
	return (*binaryClassGlGetSynciv)(nil)
}
func doEncodeGlGetSynciv(e binary.Encoder, o *GlGetSynciv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSynciv(d binary.Decoder, o *GlGetSynciv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSynciv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSynciv) ID() binary.ID      { return binaryIDGlGetSynciv }
func (*binaryClassGlGetSynciv) New() binary.Object { return &GlGetSynciv{} }
func (*binaryClassGlGetSynciv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSynciv(e, obj.(*GlGetSynciv))
}
func (*binaryClassGlGetSynciv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSynciv{}
	return obj, doDecodeGlGetSynciv(d, obj)
}
func (*binaryClassGlGetSynciv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSynciv(d, obj.(*GlGetSynciv))
}
func (*binaryClassGlGetSynciv) Skip(d binary.Decoder) error { return doSkipGlGetSynciv(d) }
func (*binaryClassGlGetSynciv) Schema() *schema.Class       { return schemaGlGetSynciv }

var schemaGlGetSynciv = &schema.Class{
	TypeID:  binaryIDGlGetSynciv,
	Package: "gles",
	Name:    "GlGetSynciv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetSyncivAPPLE struct{}

func (*GlGetSyncivAPPLE) Class() binary.Class {
	return (*binaryClassGlGetSyncivAPPLE)(nil)
}
func doEncodeGlGetSyncivAPPLE(e binary.Encoder, o *GlGetSyncivAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetSyncivAPPLE(d binary.Decoder, o *GlGetSyncivAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetSyncivAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetSyncivAPPLE) ID() binary.ID      { return binaryIDGlGetSyncivAPPLE }
func (*binaryClassGlGetSyncivAPPLE) New() binary.Object { return &GlGetSyncivAPPLE{} }
func (*binaryClassGlGetSyncivAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetSyncivAPPLE(e, obj.(*GlGetSyncivAPPLE))
}
func (*binaryClassGlGetSyncivAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetSyncivAPPLE{}
	return obj, doDecodeGlGetSyncivAPPLE(d, obj)
}
func (*binaryClassGlGetSyncivAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetSyncivAPPLE(d, obj.(*GlGetSyncivAPPLE))
}
func (*binaryClassGlGetSyncivAPPLE) Skip(d binary.Decoder) error { return doSkipGlGetSyncivAPPLE(d) }
func (*binaryClassGlGetSyncivAPPLE) Schema() *schema.Class       { return schemaGlGetSyncivAPPLE }

var schemaGlGetSyncivAPPLE = &schema.Class{
	TypeID:  binaryIDGlGetSyncivAPPLE,
	Package: "gles",
	Name:    "GlGetSyncivAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexLevelParameterfv struct{}

func (*GlGetTexLevelParameterfv) Class() binary.Class {
	return (*binaryClassGlGetTexLevelParameterfv)(nil)
}
func doEncodeGlGetTexLevelParameterfv(e binary.Encoder, o *GlGetTexLevelParameterfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexLevelParameterfv(d binary.Decoder, o *GlGetTexLevelParameterfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexLevelParameterfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexLevelParameterfv) ID() binary.ID      { return binaryIDGlGetTexLevelParameterfv }
func (*binaryClassGlGetTexLevelParameterfv) New() binary.Object { return &GlGetTexLevelParameterfv{} }
func (*binaryClassGlGetTexLevelParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexLevelParameterfv(e, obj.(*GlGetTexLevelParameterfv))
}
func (*binaryClassGlGetTexLevelParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexLevelParameterfv{}
	return obj, doDecodeGlGetTexLevelParameterfv(d, obj)
}
func (*binaryClassGlGetTexLevelParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexLevelParameterfv(d, obj.(*GlGetTexLevelParameterfv))
}
func (*binaryClassGlGetTexLevelParameterfv) Skip(d binary.Decoder) error {
	return doSkipGlGetTexLevelParameterfv(d)
}
func (*binaryClassGlGetTexLevelParameterfv) Schema() *schema.Class {
	return schemaGlGetTexLevelParameterfv
}

var schemaGlGetTexLevelParameterfv = &schema.Class{
	TypeID:  binaryIDGlGetTexLevelParameterfv,
	Package: "gles",
	Name:    "GlGetTexLevelParameterfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexLevelParameteriv struct{}

func (*GlGetTexLevelParameteriv) Class() binary.Class {
	return (*binaryClassGlGetTexLevelParameteriv)(nil)
}
func doEncodeGlGetTexLevelParameteriv(e binary.Encoder, o *GlGetTexLevelParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexLevelParameteriv(d binary.Decoder, o *GlGetTexLevelParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexLevelParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexLevelParameteriv) ID() binary.ID      { return binaryIDGlGetTexLevelParameteriv }
func (*binaryClassGlGetTexLevelParameteriv) New() binary.Object { return &GlGetTexLevelParameteriv{} }
func (*binaryClassGlGetTexLevelParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexLevelParameteriv(e, obj.(*GlGetTexLevelParameteriv))
}
func (*binaryClassGlGetTexLevelParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexLevelParameteriv{}
	return obj, doDecodeGlGetTexLevelParameteriv(d, obj)
}
func (*binaryClassGlGetTexLevelParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexLevelParameteriv(d, obj.(*GlGetTexLevelParameteriv))
}
func (*binaryClassGlGetTexLevelParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetTexLevelParameteriv(d)
}
func (*binaryClassGlGetTexLevelParameteriv) Schema() *schema.Class {
	return schemaGlGetTexLevelParameteriv
}

var schemaGlGetTexLevelParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetTexLevelParameteriv,
	Package: "gles",
	Name:    "GlGetTexLevelParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameterIivEXT struct{}

func (*GlGetTexParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIivEXT)(nil)
}
func doEncodeGlGetTexParameterIivEXT(e binary.Encoder, o *GlGetTexParameterIivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameterIivEXT(d binary.Decoder, o *GlGetTexParameterIivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameterIivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameterIivEXT) ID() binary.ID      { return binaryIDGlGetTexParameterIivEXT }
func (*binaryClassGlGetTexParameterIivEXT) New() binary.Object { return &GlGetTexParameterIivEXT{} }
func (*binaryClassGlGetTexParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameterIivEXT(e, obj.(*GlGetTexParameterIivEXT))
}
func (*binaryClassGlGetTexParameterIivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameterIivEXT{}
	return obj, doDecodeGlGetTexParameterIivEXT(d, obj)
}
func (*binaryClassGlGetTexParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameterIivEXT(d, obj.(*GlGetTexParameterIivEXT))
}
func (*binaryClassGlGetTexParameterIivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameterIivEXT(d)
}
func (*binaryClassGlGetTexParameterIivEXT) Schema() *schema.Class {
	return schemaGlGetTexParameterIivEXT
}

var schemaGlGetTexParameterIivEXT = &schema.Class{
	TypeID:  binaryIDGlGetTexParameterIivEXT,
	Package: "gles",
	Name:    "GlGetTexParameterIivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameterIivOES struct{}

func (*GlGetTexParameterIivOES) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIivOES)(nil)
}
func doEncodeGlGetTexParameterIivOES(e binary.Encoder, o *GlGetTexParameterIivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameterIivOES(d binary.Decoder, o *GlGetTexParameterIivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameterIivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameterIivOES) ID() binary.ID      { return binaryIDGlGetTexParameterIivOES }
func (*binaryClassGlGetTexParameterIivOES) New() binary.Object { return &GlGetTexParameterIivOES{} }
func (*binaryClassGlGetTexParameterIivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameterIivOES(e, obj.(*GlGetTexParameterIivOES))
}
func (*binaryClassGlGetTexParameterIivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameterIivOES{}
	return obj, doDecodeGlGetTexParameterIivOES(d, obj)
}
func (*binaryClassGlGetTexParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameterIivOES(d, obj.(*GlGetTexParameterIivOES))
}
func (*binaryClassGlGetTexParameterIivOES) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameterIivOES(d)
}
func (*binaryClassGlGetTexParameterIivOES) Schema() *schema.Class {
	return schemaGlGetTexParameterIivOES
}

var schemaGlGetTexParameterIivOES = &schema.Class{
	TypeID:  binaryIDGlGetTexParameterIivOES,
	Package: "gles",
	Name:    "GlGetTexParameterIivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameterIuivEXT struct{}

func (*GlGetTexParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIuivEXT)(nil)
}
func doEncodeGlGetTexParameterIuivEXT(e binary.Encoder, o *GlGetTexParameterIuivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameterIuivEXT(d binary.Decoder, o *GlGetTexParameterIuivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameterIuivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameterIuivEXT) ID() binary.ID      { return binaryIDGlGetTexParameterIuivEXT }
func (*binaryClassGlGetTexParameterIuivEXT) New() binary.Object { return &GlGetTexParameterIuivEXT{} }
func (*binaryClassGlGetTexParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameterIuivEXT(e, obj.(*GlGetTexParameterIuivEXT))
}
func (*binaryClassGlGetTexParameterIuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameterIuivEXT{}
	return obj, doDecodeGlGetTexParameterIuivEXT(d, obj)
}
func (*binaryClassGlGetTexParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameterIuivEXT(d, obj.(*GlGetTexParameterIuivEXT))
}
func (*binaryClassGlGetTexParameterIuivEXT) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameterIuivEXT(d)
}
func (*binaryClassGlGetTexParameterIuivEXT) Schema() *schema.Class {
	return schemaGlGetTexParameterIuivEXT
}

var schemaGlGetTexParameterIuivEXT = &schema.Class{
	TypeID:  binaryIDGlGetTexParameterIuivEXT,
	Package: "gles",
	Name:    "GlGetTexParameterIuivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameterIuivOES struct{}

func (*GlGetTexParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlGetTexParameterIuivOES)(nil)
}
func doEncodeGlGetTexParameterIuivOES(e binary.Encoder, o *GlGetTexParameterIuivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameterIuivOES(d binary.Decoder, o *GlGetTexParameterIuivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameterIuivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameterIuivOES) ID() binary.ID      { return binaryIDGlGetTexParameterIuivOES }
func (*binaryClassGlGetTexParameterIuivOES) New() binary.Object { return &GlGetTexParameterIuivOES{} }
func (*binaryClassGlGetTexParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameterIuivOES(e, obj.(*GlGetTexParameterIuivOES))
}
func (*binaryClassGlGetTexParameterIuivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameterIuivOES{}
	return obj, doDecodeGlGetTexParameterIuivOES(d, obj)
}
func (*binaryClassGlGetTexParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameterIuivOES(d, obj.(*GlGetTexParameterIuivOES))
}
func (*binaryClassGlGetTexParameterIuivOES) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameterIuivOES(d)
}
func (*binaryClassGlGetTexParameterIuivOES) Schema() *schema.Class {
	return schemaGlGetTexParameterIuivOES
}

var schemaGlGetTexParameterIuivOES = &schema.Class{
	TypeID:  binaryIDGlGetTexParameterIuivOES,
	Package: "gles",
	Name:    "GlGetTexParameterIuivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameterfv struct{}

func (*GlGetTexParameterfv) Class() binary.Class {
	return (*binaryClassGlGetTexParameterfv)(nil)
}
func doEncodeGlGetTexParameterfv(e binary.Encoder, o *GlGetTexParameterfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameterfv(d binary.Decoder, o *GlGetTexParameterfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameterfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameterfv) ID() binary.ID      { return binaryIDGlGetTexParameterfv }
func (*binaryClassGlGetTexParameterfv) New() binary.Object { return &GlGetTexParameterfv{} }
func (*binaryClassGlGetTexParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameterfv(e, obj.(*GlGetTexParameterfv))
}
func (*binaryClassGlGetTexParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameterfv{}
	return obj, doDecodeGlGetTexParameterfv(d, obj)
}
func (*binaryClassGlGetTexParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameterfv(d, obj.(*GlGetTexParameterfv))
}
func (*binaryClassGlGetTexParameterfv) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameterfv(d)
}
func (*binaryClassGlGetTexParameterfv) Schema() *schema.Class { return schemaGlGetTexParameterfv }

var schemaGlGetTexParameterfv = &schema.Class{
	TypeID:  binaryIDGlGetTexParameterfv,
	Package: "gles",
	Name:    "GlGetTexParameterfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTexParameteriv struct{}

func (*GlGetTexParameteriv) Class() binary.Class {
	return (*binaryClassGlGetTexParameteriv)(nil)
}
func doEncodeGlGetTexParameteriv(e binary.Encoder, o *GlGetTexParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTexParameteriv(d binary.Decoder, o *GlGetTexParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTexParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTexParameteriv) ID() binary.ID      { return binaryIDGlGetTexParameteriv }
func (*binaryClassGlGetTexParameteriv) New() binary.Object { return &GlGetTexParameteriv{} }
func (*binaryClassGlGetTexParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTexParameteriv(e, obj.(*GlGetTexParameteriv))
}
func (*binaryClassGlGetTexParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTexParameteriv{}
	return obj, doDecodeGlGetTexParameteriv(d, obj)
}
func (*binaryClassGlGetTexParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTexParameteriv(d, obj.(*GlGetTexParameteriv))
}
func (*binaryClassGlGetTexParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlGetTexParameteriv(d)
}
func (*binaryClassGlGetTexParameteriv) Schema() *schema.Class { return schemaGlGetTexParameteriv }

var schemaGlGetTexParameteriv = &schema.Class{
	TypeID:  binaryIDGlGetTexParameteriv,
	Package: "gles",
	Name:    "GlGetTexParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTextureHandleNV struct{}

func (*GlGetTextureHandleNV) Class() binary.Class {
	return (*binaryClassGlGetTextureHandleNV)(nil)
}
func doEncodeGlGetTextureHandleNV(e binary.Encoder, o *GlGetTextureHandleNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTextureHandleNV(d binary.Decoder, o *GlGetTextureHandleNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = GLuint64(obj)
	}
	return nil
}
func doSkipGlGetTextureHandleNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTextureHandleNV) ID() binary.ID      { return binaryIDGlGetTextureHandleNV }
func (*binaryClassGlGetTextureHandleNV) New() binary.Object { return &GlGetTextureHandleNV{} }
func (*binaryClassGlGetTextureHandleNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTextureHandleNV(e, obj.(*GlGetTextureHandleNV))
}
func (*binaryClassGlGetTextureHandleNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTextureHandleNV{}
	return obj, doDecodeGlGetTextureHandleNV(d, obj)
}
func (*binaryClassGlGetTextureHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTextureHandleNV(d, obj.(*GlGetTextureHandleNV))
}
func (*binaryClassGlGetTextureHandleNV) Skip(d binary.Decoder) error {
	return doSkipGlGetTextureHandleNV(d)
}
func (*binaryClassGlGetTextureHandleNV) Schema() *schema.Class { return schemaGlGetTextureHandleNV }

var schemaGlGetTextureHandleNV = &schema.Class{
	TypeID:  binaryIDGlGetTextureHandleNV,
	Package: "gles",
	Name:    "GlGetTextureHandleNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlGetTextureSamplerHandleNV struct{}

func (*GlGetTextureSamplerHandleNV) Class() binary.Class {
	return (*binaryClassGlGetTextureSamplerHandleNV)(nil)
}
func doEncodeGlGetTextureSamplerHandleNV(e binary.Encoder, o *GlGetTextureSamplerHandleNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTextureSamplerHandleNV(d binary.Decoder, o *GlGetTextureSamplerHandleNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = GLuint64(obj)
	}
	return nil
}
func doSkipGlGetTextureSamplerHandleNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTextureSamplerHandleNV) ID() binary.ID {
	return binaryIDGlGetTextureSamplerHandleNV
}
func (*binaryClassGlGetTextureSamplerHandleNV) New() binary.Object {
	return &GlGetTextureSamplerHandleNV{}
}
func (*binaryClassGlGetTextureSamplerHandleNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTextureSamplerHandleNV(e, obj.(*GlGetTextureSamplerHandleNV))
}
func (*binaryClassGlGetTextureSamplerHandleNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTextureSamplerHandleNV{}
	return obj, doDecodeGlGetTextureSamplerHandleNV(d, obj)
}
func (*binaryClassGlGetTextureSamplerHandleNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTextureSamplerHandleNV(d, obj.(*GlGetTextureSamplerHandleNV))
}
func (*binaryClassGlGetTextureSamplerHandleNV) Skip(d binary.Decoder) error {
	return doSkipGlGetTextureSamplerHandleNV(d)
}
func (*binaryClassGlGetTextureSamplerHandleNV) Schema() *schema.Class {
	return schemaGlGetTextureSamplerHandleNV
}

var schemaGlGetTextureSamplerHandleNV = &schema.Class{
	TypeID:  binaryIDGlGetTextureSamplerHandleNV,
	Package: "gles",
	Name:    "GlGetTextureSamplerHandleNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlGetTransformFeedbackVarying struct{}

func (*GlGetTransformFeedbackVarying) Class() binary.Class {
	return (*binaryClassGlGetTransformFeedbackVarying)(nil)
}
func doEncodeGlGetTransformFeedbackVarying(e binary.Encoder, o *GlGetTransformFeedbackVarying) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Size); err != nil {
		return err
	}
	if err := e.Value(&o.Type); err != nil {
		return err
	}
	if err := e.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTransformFeedbackVarying(d binary.Decoder, o *GlGetTransformFeedbackVarying) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Size); err != nil {
		return err
	}
	if err := d.Value(&o.Type); err != nil {
		return err
	}
	if err := d.Value(&o.Name); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTransformFeedbackVarying(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTransformFeedbackVarying) ID() binary.ID {
	return binaryIDGlGetTransformFeedbackVarying
}
func (*binaryClassGlGetTransformFeedbackVarying) New() binary.Object {
	return &GlGetTransformFeedbackVarying{}
}
func (*binaryClassGlGetTransformFeedbackVarying) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTransformFeedbackVarying(e, obj.(*GlGetTransformFeedbackVarying))
}
func (*binaryClassGlGetTransformFeedbackVarying) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTransformFeedbackVarying{}
	return obj, doDecodeGlGetTransformFeedbackVarying(d, obj)
}
func (*binaryClassGlGetTransformFeedbackVarying) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTransformFeedbackVarying(d, obj.(*GlGetTransformFeedbackVarying))
}
func (*binaryClassGlGetTransformFeedbackVarying) Skip(d binary.Decoder) error {
	return doSkipGlGetTransformFeedbackVarying(d)
}
func (*binaryClassGlGetTransformFeedbackVarying) Schema() *schema.Class {
	return schemaGlGetTransformFeedbackVarying
}

var schemaGlGetTransformFeedbackVarying = &schema.Class{
	TypeID:  binaryIDGlGetTransformFeedbackVarying,
	Package: "gles",
	Name:    "GlGetTransformFeedbackVarying",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Size", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Struct{Name: "GLenumᵖ", ID: (*GLenumᵖ)(nil).Class().ID()}},
		{Declared: "Name", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetTranslatedShaderSourceANGLE struct{}

func (*GlGetTranslatedShaderSourceANGLE) Class() binary.Class {
	return (*binaryClassGlGetTranslatedShaderSourceANGLE)(nil)
}
func doEncodeGlGetTranslatedShaderSourceANGLE(e binary.Encoder, o *GlGetTranslatedShaderSourceANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Bufsize)); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	if err := e.Value(&o.Source); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetTranslatedShaderSourceANGLE(d binary.Decoder, o *GlGetTranslatedShaderSourceANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Bufsize = GLsizei(obj)
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	if err := d.Value(&o.Source); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetTranslatedShaderSourceANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) ID() binary.ID {
	return binaryIDGlGetTranslatedShaderSourceANGLE
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) New() binary.Object {
	return &GlGetTranslatedShaderSourceANGLE{}
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetTranslatedShaderSourceANGLE(e, obj.(*GlGetTranslatedShaderSourceANGLE))
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetTranslatedShaderSourceANGLE{}
	return obj, doDecodeGlGetTranslatedShaderSourceANGLE(d, obj)
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetTranslatedShaderSourceANGLE(d, obj.(*GlGetTranslatedShaderSourceANGLE))
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) Skip(d binary.Decoder) error {
	return doSkipGlGetTranslatedShaderSourceANGLE(d)
}
func (*binaryClassGlGetTranslatedShaderSourceANGLE) Schema() *schema.Class {
	return schemaGlGetTranslatedShaderSourceANGLE
}

var schemaGlGetTranslatedShaderSourceANGLE = &schema.Class{
	TypeID:  binaryIDGlGetTranslatedShaderSourceANGLE,
	Package: "gles",
	Name:    "GlGetTranslatedShaderSourceANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "Bufsize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLsizeiᵖ", ID: (*GLsizeiᵖ)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Struct{Name: "GLcharᵖ", ID: (*GLcharᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetUniformBlockIndex struct{}

func (*GlGetUniformBlockIndex) Class() binary.Class {
	return (*binaryClassGlGetUniformBlockIndex)(nil)
}
func doEncodeGlGetUniformBlockIndex(e binary.Encoder, o *GlGetUniformBlockIndex) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Value(&o.UniformBlockName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformBlockIndex(d binary.Decoder, o *GlGetUniformBlockIndex) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if err := d.Value(&o.UniformBlockName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = UniformBlockId(obj)
	}
	return nil
}
func doSkipGlGetUniformBlockIndex(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformBlockIndex) ID() binary.ID      { return binaryIDGlGetUniformBlockIndex }
func (*binaryClassGlGetUniformBlockIndex) New() binary.Object { return &GlGetUniformBlockIndex{} }
func (*binaryClassGlGetUniformBlockIndex) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformBlockIndex(e, obj.(*GlGetUniformBlockIndex))
}
func (*binaryClassGlGetUniformBlockIndex) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformBlockIndex{}
	return obj, doDecodeGlGetUniformBlockIndex(d, obj)
}
func (*binaryClassGlGetUniformBlockIndex) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformBlockIndex(d, obj.(*GlGetUniformBlockIndex))
}
func (*binaryClassGlGetUniformBlockIndex) Skip(d binary.Decoder) error {
	return doSkipGlGetUniformBlockIndex(d)
}
func (*binaryClassGlGetUniformBlockIndex) Schema() *schema.Class { return schemaGlGetUniformBlockIndex }

var schemaGlGetUniformBlockIndex = &schema.Class{
	TypeID:  binaryIDGlGetUniformBlockIndex,
	Package: "gles",
	Name:    "GlGetUniformBlockIndex",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformBlockName", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "UniformBlockId", Method: schema.Uint32}},
	},
}

type binaryClassGlGetUniformIndices struct{}

func (*GlGetUniformIndices) Class() binary.Class {
	return (*binaryClassGlGetUniformIndices)(nil)
}
func doEncodeGlGetUniformIndices(e binary.Encoder, o *GlGetUniformIndices) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.UniformCount)); err != nil {
		return err
	}
	if err := e.Value(&o.UniformNames); err != nil {
		return err
	}
	if err := e.Value(&o.UniformIndices); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformIndices(d binary.Decoder, o *GlGetUniformIndices) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.UniformCount = GLsizei(obj)
	}
	if err := d.Value(&o.UniformNames); err != nil {
		return err
	}
	if err := d.Value(&o.UniformIndices); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetUniformIndices(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformIndices) ID() binary.ID      { return binaryIDGlGetUniformIndices }
func (*binaryClassGlGetUniformIndices) New() binary.Object { return &GlGetUniformIndices{} }
func (*binaryClassGlGetUniformIndices) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformIndices(e, obj.(*GlGetUniformIndices))
}
func (*binaryClassGlGetUniformIndices) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformIndices{}
	return obj, doDecodeGlGetUniformIndices(d, obj)
}
func (*binaryClassGlGetUniformIndices) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformIndices(d, obj.(*GlGetUniformIndices))
}
func (*binaryClassGlGetUniformIndices) Skip(d binary.Decoder) error {
	return doSkipGlGetUniformIndices(d)
}
func (*binaryClassGlGetUniformIndices) Schema() *schema.Class { return schemaGlGetUniformIndices }

var schemaGlGetUniformIndices = &schema.Class{
	TypeID:  binaryIDGlGetUniformIndices,
	Package: "gles",
	Name:    "GlGetUniformIndices",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "UniformNames", Type: &schema.Struct{Name: "GLcharᶜᵖᶜᵖ", ID: (*GLcharᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "UniformIndices", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetUniformLocation struct{}

func (*GlGetUniformLocation) Class() binary.Class {
	return (*binaryClassGlGetUniformLocation)(nil)
}
func doEncodeGlGetUniformLocation(e binary.Encoder, o *GlGetUniformLocation) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformLocation(d binary.Decoder, o *GlGetUniformLocation) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Result = UniformLocation(obj)
	}
	return nil
}
func doSkipGlGetUniformLocation(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformLocation) ID() binary.ID      { return binaryIDGlGetUniformLocation }
func (*binaryClassGlGetUniformLocation) New() binary.Object { return &GlGetUniformLocation{} }
func (*binaryClassGlGetUniformLocation) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformLocation(e, obj.(*GlGetUniformLocation))
}
func (*binaryClassGlGetUniformLocation) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformLocation{}
	return obj, doDecodeGlGetUniformLocation(d, obj)
}
func (*binaryClassGlGetUniformLocation) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformLocation(d, obj.(*GlGetUniformLocation))
}
func (*binaryClassGlGetUniformLocation) Skip(d binary.Decoder) error {
	return doSkipGlGetUniformLocation(d)
}
func (*binaryClassGlGetUniformLocation) Schema() *schema.Class { return schemaGlGetUniformLocation }

var schemaGlGetUniformLocation = &schema.Class{
	TypeID:  binaryIDGlGetUniformLocation,
	Package: "gles",
	Name:    "GlGetUniformLocation",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "Result", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
	},
}

type binaryClassGlGetUniformfv struct{}

func (*GlGetUniformfv) Class() binary.Class {
	return (*binaryClassGlGetUniformfv)(nil)
}
func doEncodeGlGetUniformfv(e binary.Encoder, o *GlGetUniformfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformfv(d binary.Decoder, o *GlGetUniformfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetUniformfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformfv) ID() binary.ID      { return binaryIDGlGetUniformfv }
func (*binaryClassGlGetUniformfv) New() binary.Object { return &GlGetUniformfv{} }
func (*binaryClassGlGetUniformfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformfv(e, obj.(*GlGetUniformfv))
}
func (*binaryClassGlGetUniformfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformfv{}
	return obj, doDecodeGlGetUniformfv(d, obj)
}
func (*binaryClassGlGetUniformfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformfv(d, obj.(*GlGetUniformfv))
}
func (*binaryClassGlGetUniformfv) Skip(d binary.Decoder) error { return doSkipGlGetUniformfv(d) }
func (*binaryClassGlGetUniformfv) Schema() *schema.Class       { return schemaGlGetUniformfv }

var schemaGlGetUniformfv = &schema.Class{
	TypeID:  binaryIDGlGetUniformfv,
	Package: "gles",
	Name:    "GlGetUniformfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetUniformiv struct{}

func (*GlGetUniformiv) Class() binary.Class {
	return (*binaryClassGlGetUniformiv)(nil)
}
func doEncodeGlGetUniformiv(e binary.Encoder, o *GlGetUniformiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformiv(d binary.Decoder, o *GlGetUniformiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetUniformiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformiv) ID() binary.ID      { return binaryIDGlGetUniformiv }
func (*binaryClassGlGetUniformiv) New() binary.Object { return &GlGetUniformiv{} }
func (*binaryClassGlGetUniformiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformiv(e, obj.(*GlGetUniformiv))
}
func (*binaryClassGlGetUniformiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformiv{}
	return obj, doDecodeGlGetUniformiv(d, obj)
}
func (*binaryClassGlGetUniformiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformiv(d, obj.(*GlGetUniformiv))
}
func (*binaryClassGlGetUniformiv) Skip(d binary.Decoder) error { return doSkipGlGetUniformiv(d) }
func (*binaryClassGlGetUniformiv) Schema() *schema.Class       { return schemaGlGetUniformiv }

var schemaGlGetUniformiv = &schema.Class{
	TypeID:  binaryIDGlGetUniformiv,
	Package: "gles",
	Name:    "GlGetUniformiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetUniformuiv struct{}

func (*GlGetUniformuiv) Class() binary.Class {
	return (*binaryClassGlGetUniformuiv)(nil)
}
func doEncodeGlGetUniformuiv(e binary.Encoder, o *GlGetUniformuiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetUniformuiv(d binary.Decoder, o *GlGetUniformuiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetUniformuiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetUniformuiv) ID() binary.ID      { return binaryIDGlGetUniformuiv }
func (*binaryClassGlGetUniformuiv) New() binary.Object { return &GlGetUniformuiv{} }
func (*binaryClassGlGetUniformuiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetUniformuiv(e, obj.(*GlGetUniformuiv))
}
func (*binaryClassGlGetUniformuiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetUniformuiv{}
	return obj, doDecodeGlGetUniformuiv(d, obj)
}
func (*binaryClassGlGetUniformuiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetUniformuiv(d, obj.(*GlGetUniformuiv))
}
func (*binaryClassGlGetUniformuiv) Skip(d binary.Decoder) error { return doSkipGlGetUniformuiv(d) }
func (*binaryClassGlGetUniformuiv) Schema() *schema.Class       { return schemaGlGetUniformuiv }

var schemaGlGetUniformuiv = &schema.Class{
	TypeID:  binaryIDGlGetUniformuiv,
	Package: "gles",
	Name:    "GlGetUniformuiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetVertexAttribIiv struct{}

func (*GlGetVertexAttribIiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribIiv)(nil)
}
func doEncodeGlGetVertexAttribIiv(e binary.Encoder, o *GlGetVertexAttribIiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetVertexAttribIiv(d binary.Decoder, o *GlGetVertexAttribIiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetVertexAttribIiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetVertexAttribIiv) ID() binary.ID      { return binaryIDGlGetVertexAttribIiv }
func (*binaryClassGlGetVertexAttribIiv) New() binary.Object { return &GlGetVertexAttribIiv{} }
func (*binaryClassGlGetVertexAttribIiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetVertexAttribIiv(e, obj.(*GlGetVertexAttribIiv))
}
func (*binaryClassGlGetVertexAttribIiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetVertexAttribIiv{}
	return obj, doDecodeGlGetVertexAttribIiv(d, obj)
}
func (*binaryClassGlGetVertexAttribIiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetVertexAttribIiv(d, obj.(*GlGetVertexAttribIiv))
}
func (*binaryClassGlGetVertexAttribIiv) Skip(d binary.Decoder) error {
	return doSkipGlGetVertexAttribIiv(d)
}
func (*binaryClassGlGetVertexAttribIiv) Schema() *schema.Class { return schemaGlGetVertexAttribIiv }

var schemaGlGetVertexAttribIiv = &schema.Class{
	TypeID:  binaryIDGlGetVertexAttribIiv,
	Package: "gles",
	Name:    "GlGetVertexAttribIiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetVertexAttribIuiv struct{}

func (*GlGetVertexAttribIuiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribIuiv)(nil)
}
func doEncodeGlGetVertexAttribIuiv(e binary.Encoder, o *GlGetVertexAttribIuiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetVertexAttribIuiv(d binary.Decoder, o *GlGetVertexAttribIuiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetVertexAttribIuiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetVertexAttribIuiv) ID() binary.ID      { return binaryIDGlGetVertexAttribIuiv }
func (*binaryClassGlGetVertexAttribIuiv) New() binary.Object { return &GlGetVertexAttribIuiv{} }
func (*binaryClassGlGetVertexAttribIuiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetVertexAttribIuiv(e, obj.(*GlGetVertexAttribIuiv))
}
func (*binaryClassGlGetVertexAttribIuiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetVertexAttribIuiv{}
	return obj, doDecodeGlGetVertexAttribIuiv(d, obj)
}
func (*binaryClassGlGetVertexAttribIuiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetVertexAttribIuiv(d, obj.(*GlGetVertexAttribIuiv))
}
func (*binaryClassGlGetVertexAttribIuiv) Skip(d binary.Decoder) error {
	return doSkipGlGetVertexAttribIuiv(d)
}
func (*binaryClassGlGetVertexAttribIuiv) Schema() *schema.Class { return schemaGlGetVertexAttribIuiv }

var schemaGlGetVertexAttribIuiv = &schema.Class{
	TypeID:  binaryIDGlGetVertexAttribIuiv,
	Package: "gles",
	Name:    "GlGetVertexAttribIuiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetVertexAttribPointerv struct{}

func (*GlGetVertexAttribPointerv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribPointerv)(nil)
}
func doEncodeGlGetVertexAttribPointerv(e binary.Encoder, o *GlGetVertexAttribPointerv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetVertexAttribPointerv(d binary.Decoder, o *GlGetVertexAttribPointerv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetVertexAttribPointerv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetVertexAttribPointerv) ID() binary.ID      { return binaryIDGlGetVertexAttribPointerv }
func (*binaryClassGlGetVertexAttribPointerv) New() binary.Object { return &GlGetVertexAttribPointerv{} }
func (*binaryClassGlGetVertexAttribPointerv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetVertexAttribPointerv(e, obj.(*GlGetVertexAttribPointerv))
}
func (*binaryClassGlGetVertexAttribPointerv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetVertexAttribPointerv{}
	return obj, doDecodeGlGetVertexAttribPointerv(d, obj)
}
func (*binaryClassGlGetVertexAttribPointerv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetVertexAttribPointerv(d, obj.(*GlGetVertexAttribPointerv))
}
func (*binaryClassGlGetVertexAttribPointerv) Skip(d binary.Decoder) error {
	return doSkipGlGetVertexAttribPointerv(d)
}
func (*binaryClassGlGetVertexAttribPointerv) Schema() *schema.Class {
	return schemaGlGetVertexAttribPointerv
}

var schemaGlGetVertexAttribPointerv = &schema.Class{
	TypeID:  binaryIDGlGetVertexAttribPointerv,
	Package: "gles",
	Name:    "GlGetVertexAttribPointerv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pointer", Type: &schema.Struct{Name: "Voidᵖᵖ", ID: (*Voidᵖᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetVertexAttribfv struct{}

func (*GlGetVertexAttribfv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribfv)(nil)
}
func doEncodeGlGetVertexAttribfv(e binary.Encoder, o *GlGetVertexAttribfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetVertexAttribfv(d binary.Decoder, o *GlGetVertexAttribfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetVertexAttribfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetVertexAttribfv) ID() binary.ID      { return binaryIDGlGetVertexAttribfv }
func (*binaryClassGlGetVertexAttribfv) New() binary.Object { return &GlGetVertexAttribfv{} }
func (*binaryClassGlGetVertexAttribfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetVertexAttribfv(e, obj.(*GlGetVertexAttribfv))
}
func (*binaryClassGlGetVertexAttribfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetVertexAttribfv{}
	return obj, doDecodeGlGetVertexAttribfv(d, obj)
}
func (*binaryClassGlGetVertexAttribfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetVertexAttribfv(d, obj.(*GlGetVertexAttribfv))
}
func (*binaryClassGlGetVertexAttribfv) Skip(d binary.Decoder) error {
	return doSkipGlGetVertexAttribfv(d)
}
func (*binaryClassGlGetVertexAttribfv) Schema() *schema.Class { return schemaGlGetVertexAttribfv }

var schemaGlGetVertexAttribfv = &schema.Class{
	TypeID:  binaryIDGlGetVertexAttribfv,
	Package: "gles",
	Name:    "GlGetVertexAttribfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetVertexAttribiv struct{}

func (*GlGetVertexAttribiv) Class() binary.Class {
	return (*binaryClassGlGetVertexAttribiv)(nil)
}
func doEncodeGlGetVertexAttribiv(e binary.Encoder, o *GlGetVertexAttribiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetVertexAttribiv(d binary.Decoder, o *GlGetVertexAttribiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetVertexAttribiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetVertexAttribiv) ID() binary.ID      { return binaryIDGlGetVertexAttribiv }
func (*binaryClassGlGetVertexAttribiv) New() binary.Object { return &GlGetVertexAttribiv{} }
func (*binaryClassGlGetVertexAttribiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetVertexAttribiv(e, obj.(*GlGetVertexAttribiv))
}
func (*binaryClassGlGetVertexAttribiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetVertexAttribiv{}
	return obj, doDecodeGlGetVertexAttribiv(d, obj)
}
func (*binaryClassGlGetVertexAttribiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetVertexAttribiv(d, obj.(*GlGetVertexAttribiv))
}
func (*binaryClassGlGetVertexAttribiv) Skip(d binary.Decoder) error {
	return doSkipGlGetVertexAttribiv(d)
}
func (*binaryClassGlGetVertexAttribiv) Schema() *schema.Class { return schemaGlGetVertexAttribiv }

var schemaGlGetVertexAttribiv = &schema.Class{
	TypeID:  binaryIDGlGetVertexAttribiv,
	Package: "gles",
	Name:    "GlGetVertexAttribiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetnUniformfvEXT struct{}

func (*GlGetnUniformfvEXT) Class() binary.Class {
	return (*binaryClassGlGetnUniformfvEXT)(nil)
}
func doEncodeGlGetnUniformfvEXT(e binary.Encoder, o *GlGetnUniformfvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetnUniformfvEXT(d binary.Decoder, o *GlGetnUniformfvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetnUniformfvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetnUniformfvEXT) ID() binary.ID      { return binaryIDGlGetnUniformfvEXT }
func (*binaryClassGlGetnUniformfvEXT) New() binary.Object { return &GlGetnUniformfvEXT{} }
func (*binaryClassGlGetnUniformfvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetnUniformfvEXT(e, obj.(*GlGetnUniformfvEXT))
}
func (*binaryClassGlGetnUniformfvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetnUniformfvEXT{}
	return obj, doDecodeGlGetnUniformfvEXT(d, obj)
}
func (*binaryClassGlGetnUniformfvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetnUniformfvEXT(d, obj.(*GlGetnUniformfvEXT))
}
func (*binaryClassGlGetnUniformfvEXT) Skip(d binary.Decoder) error { return doSkipGlGetnUniformfvEXT(d) }
func (*binaryClassGlGetnUniformfvEXT) Schema() *schema.Class       { return schemaGlGetnUniformfvEXT }

var schemaGlGetnUniformfvEXT = &schema.Class{
	TypeID:  binaryIDGlGetnUniformfvEXT,
	Package: "gles",
	Name:    "GlGetnUniformfvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetnUniformfvKHR struct{}

func (*GlGetnUniformfvKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformfvKHR)(nil)
}
func doEncodeGlGetnUniformfvKHR(e binary.Encoder, o *GlGetnUniformfvKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetnUniformfvKHR(d binary.Decoder, o *GlGetnUniformfvKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetnUniformfvKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetnUniformfvKHR) ID() binary.ID      { return binaryIDGlGetnUniformfvKHR }
func (*binaryClassGlGetnUniformfvKHR) New() binary.Object { return &GlGetnUniformfvKHR{} }
func (*binaryClassGlGetnUniformfvKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetnUniformfvKHR(e, obj.(*GlGetnUniformfvKHR))
}
func (*binaryClassGlGetnUniformfvKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetnUniformfvKHR{}
	return obj, doDecodeGlGetnUniformfvKHR(d, obj)
}
func (*binaryClassGlGetnUniformfvKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetnUniformfvKHR(d, obj.(*GlGetnUniformfvKHR))
}
func (*binaryClassGlGetnUniformfvKHR) Skip(d binary.Decoder) error { return doSkipGlGetnUniformfvKHR(d) }
func (*binaryClassGlGetnUniformfvKHR) Schema() *schema.Class       { return schemaGlGetnUniformfvKHR }

var schemaGlGetnUniformfvKHR = &schema.Class{
	TypeID:  binaryIDGlGetnUniformfvKHR,
	Package: "gles",
	Name:    "GlGetnUniformfvKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetnUniformivEXT struct{}

func (*GlGetnUniformivEXT) Class() binary.Class {
	return (*binaryClassGlGetnUniformivEXT)(nil)
}
func doEncodeGlGetnUniformivEXT(e binary.Encoder, o *GlGetnUniformivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetnUniformivEXT(d binary.Decoder, o *GlGetnUniformivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetnUniformivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetnUniformivEXT) ID() binary.ID      { return binaryIDGlGetnUniformivEXT }
func (*binaryClassGlGetnUniformivEXT) New() binary.Object { return &GlGetnUniformivEXT{} }
func (*binaryClassGlGetnUniformivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetnUniformivEXT(e, obj.(*GlGetnUniformivEXT))
}
func (*binaryClassGlGetnUniformivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetnUniformivEXT{}
	return obj, doDecodeGlGetnUniformivEXT(d, obj)
}
func (*binaryClassGlGetnUniformivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetnUniformivEXT(d, obj.(*GlGetnUniformivEXT))
}
func (*binaryClassGlGetnUniformivEXT) Skip(d binary.Decoder) error { return doSkipGlGetnUniformivEXT(d) }
func (*binaryClassGlGetnUniformivEXT) Schema() *schema.Class       { return schemaGlGetnUniformivEXT }

var schemaGlGetnUniformivEXT = &schema.Class{
	TypeID:  binaryIDGlGetnUniformivEXT,
	Package: "gles",
	Name:    "GlGetnUniformivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetnUniformivKHR struct{}

func (*GlGetnUniformivKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformivKHR)(nil)
}
func doEncodeGlGetnUniformivKHR(e binary.Encoder, o *GlGetnUniformivKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetnUniformivKHR(d binary.Decoder, o *GlGetnUniformivKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetnUniformivKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetnUniformivKHR) ID() binary.ID      { return binaryIDGlGetnUniformivKHR }
func (*binaryClassGlGetnUniformivKHR) New() binary.Object { return &GlGetnUniformivKHR{} }
func (*binaryClassGlGetnUniformivKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetnUniformivKHR(e, obj.(*GlGetnUniformivKHR))
}
func (*binaryClassGlGetnUniformivKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetnUniformivKHR{}
	return obj, doDecodeGlGetnUniformivKHR(d, obj)
}
func (*binaryClassGlGetnUniformivKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetnUniformivKHR(d, obj.(*GlGetnUniformivKHR))
}
func (*binaryClassGlGetnUniformivKHR) Skip(d binary.Decoder) error { return doSkipGlGetnUniformivKHR(d) }
func (*binaryClassGlGetnUniformivKHR) Schema() *schema.Class       { return schemaGlGetnUniformivKHR }

var schemaGlGetnUniformivKHR = &schema.Class{
	TypeID:  binaryIDGlGetnUniformivKHR,
	Package: "gles",
	Name:    "GlGetnUniformivKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᵖ", ID: (*GLintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlGetnUniformuivKHR struct{}

func (*GlGetnUniformuivKHR) Class() binary.Class {
	return (*binaryClassGlGetnUniformuivKHR)(nil)
}
func doEncodeGlGetnUniformuivKHR(e binary.Encoder, o *GlGetnUniformuivKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlGetnUniformuivKHR(d binary.Decoder, o *GlGetnUniformuivKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlGetnUniformuivKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlGetnUniformuivKHR) ID() binary.ID      { return binaryIDGlGetnUniformuivKHR }
func (*binaryClassGlGetnUniformuivKHR) New() binary.Object { return &GlGetnUniformuivKHR{} }
func (*binaryClassGlGetnUniformuivKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlGetnUniformuivKHR(e, obj.(*GlGetnUniformuivKHR))
}
func (*binaryClassGlGetnUniformuivKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlGetnUniformuivKHR{}
	return obj, doDecodeGlGetnUniformuivKHR(d, obj)
}
func (*binaryClassGlGetnUniformuivKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlGetnUniformuivKHR(d, obj.(*GlGetnUniformuivKHR))
}
func (*binaryClassGlGetnUniformuivKHR) Skip(d binary.Decoder) error {
	return doSkipGlGetnUniformuivKHR(d)
}
func (*binaryClassGlGetnUniformuivKHR) Schema() *schema.Class { return schemaGlGetnUniformuivKHR }

var schemaGlGetnUniformuivKHR = &schema.Class{
	TypeID:  binaryIDGlGetnUniformuivKHR,
	Package: "gles",
	Name:    "GlGetnUniformuivKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlHint struct{}

func (*GlHint) Class() binary.Class {
	return (*binaryClassGlHint)(nil)
}
func doEncodeGlHint(e binary.Encoder, o *GlHint) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlHint(d binary.Decoder, o *GlHint) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlHint(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlHint) ID() binary.ID      { return binaryIDGlHint }
func (*binaryClassGlHint) New() binary.Object { return &GlHint{} }
func (*binaryClassGlHint) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlHint(e, obj.(*GlHint))
}
func (*binaryClassGlHint) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlHint{}
	return obj, doDecodeGlHint(d, obj)
}
func (*binaryClassGlHint) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlHint(d, obj.(*GlHint))
}
func (*binaryClassGlHint) Skip(d binary.Decoder) error { return doSkipGlHint(d) }
func (*binaryClassGlHint) Schema() *schema.Class       { return schemaGlHint }

var schemaGlHint = &schema.Class{
	TypeID:  binaryIDGlHint,
	Package: "gles",
	Name:    "GlHint",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlInsertEventMarkerEXT struct{}

func (*GlInsertEventMarkerEXT) Class() binary.Class {
	return (*binaryClassGlInsertEventMarkerEXT)(nil)
}
func doEncodeGlInsertEventMarkerEXT(e binary.Encoder, o *GlInsertEventMarkerEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Marker); err != nil {
		return err
	}
	return nil
}
func doDecodeGlInsertEventMarkerEXT(d binary.Decoder, o *GlInsertEventMarkerEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Marker); err != nil {
		return err
	}
	return nil
}
func doSkipGlInsertEventMarkerEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlInsertEventMarkerEXT) ID() binary.ID      { return binaryIDGlInsertEventMarkerEXT }
func (*binaryClassGlInsertEventMarkerEXT) New() binary.Object { return &GlInsertEventMarkerEXT{} }
func (*binaryClassGlInsertEventMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlInsertEventMarkerEXT(e, obj.(*GlInsertEventMarkerEXT))
}
func (*binaryClassGlInsertEventMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlInsertEventMarkerEXT{}
	return obj, doDecodeGlInsertEventMarkerEXT(d, obj)
}
func (*binaryClassGlInsertEventMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlInsertEventMarkerEXT(d, obj.(*GlInsertEventMarkerEXT))
}
func (*binaryClassGlInsertEventMarkerEXT) Skip(d binary.Decoder) error {
	return doSkipGlInsertEventMarkerEXT(d)
}
func (*binaryClassGlInsertEventMarkerEXT) Schema() *schema.Class { return schemaGlInsertEventMarkerEXT }

var schemaGlInsertEventMarkerEXT = &schema.Class{
	TypeID:  binaryIDGlInsertEventMarkerEXT,
	Package: "gles",
	Name:    "GlInsertEventMarkerEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Marker", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlInterpolatePathsNV struct{}

func (*GlInterpolatePathsNV) Class() binary.Class {
	return (*binaryClassGlInterpolatePathsNV)(nil)
}
func doEncodeGlInterpolatePathsNV(e binary.Encoder, o *GlInterpolatePathsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ResultPath)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathA)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathB)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Weight)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlInterpolatePathsNV(d binary.Decoder, o *GlInterpolatePathsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ResultPath = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathA = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathB = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Weight = GLfloat(obj)
	}
	return nil
}
func doSkipGlInterpolatePathsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlInterpolatePathsNV) ID() binary.ID      { return binaryIDGlInterpolatePathsNV }
func (*binaryClassGlInterpolatePathsNV) New() binary.Object { return &GlInterpolatePathsNV{} }
func (*binaryClassGlInterpolatePathsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlInterpolatePathsNV(e, obj.(*GlInterpolatePathsNV))
}
func (*binaryClassGlInterpolatePathsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlInterpolatePathsNV{}
	return obj, doDecodeGlInterpolatePathsNV(d, obj)
}
func (*binaryClassGlInterpolatePathsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlInterpolatePathsNV(d, obj.(*GlInterpolatePathsNV))
}
func (*binaryClassGlInterpolatePathsNV) Skip(d binary.Decoder) error {
	return doSkipGlInterpolatePathsNV(d)
}
func (*binaryClassGlInterpolatePathsNV) Schema() *schema.Class { return schemaGlInterpolatePathsNV }

var schemaGlInterpolatePathsNV = &schema.Class{
	TypeID:  binaryIDGlInterpolatePathsNV,
	Package: "gles",
	Name:    "GlInterpolatePathsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ResultPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "PathA", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "PathB", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Weight", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlInvalidateFramebuffer struct{}

func (*GlInvalidateFramebuffer) Class() binary.Class {
	return (*binaryClassGlInvalidateFramebuffer)(nil)
}
func doEncodeGlInvalidateFramebuffer(e binary.Encoder, o *GlInvalidateFramebuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Attachments); err != nil {
		return err
	}
	return nil
}
func doDecodeGlInvalidateFramebuffer(d binary.Decoder, o *GlInvalidateFramebuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Attachments); err != nil {
		return err
	}
	return nil
}
func doSkipGlInvalidateFramebuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlInvalidateFramebuffer) ID() binary.ID      { return binaryIDGlInvalidateFramebuffer }
func (*binaryClassGlInvalidateFramebuffer) New() binary.Object { return &GlInvalidateFramebuffer{} }
func (*binaryClassGlInvalidateFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlInvalidateFramebuffer(e, obj.(*GlInvalidateFramebuffer))
}
func (*binaryClassGlInvalidateFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlInvalidateFramebuffer{}
	return obj, doDecodeGlInvalidateFramebuffer(d, obj)
}
func (*binaryClassGlInvalidateFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlInvalidateFramebuffer(d, obj.(*GlInvalidateFramebuffer))
}
func (*binaryClassGlInvalidateFramebuffer) Skip(d binary.Decoder) error {
	return doSkipGlInvalidateFramebuffer(d)
}
func (*binaryClassGlInvalidateFramebuffer) Schema() *schema.Class {
	return schemaGlInvalidateFramebuffer
}

var schemaGlInvalidateFramebuffer = &schema.Class{
	TypeID:  binaryIDGlInvalidateFramebuffer,
	Package: "gles",
	Name:    "GlInvalidateFramebuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Attachments", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlInvalidateSubFramebuffer struct{}

func (*GlInvalidateSubFramebuffer) Class() binary.Class {
	return (*binaryClassGlInvalidateSubFramebuffer)(nil)
}
func doEncodeGlInvalidateSubFramebuffer(e binary.Encoder, o *GlInvalidateSubFramebuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumAttachments)); err != nil {
		return err
	}
	if err := e.Value(&o.Attachments); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlInvalidateSubFramebuffer(d binary.Decoder, o *GlInvalidateSubFramebuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumAttachments = GLsizei(obj)
	}
	if err := d.Value(&o.Attachments); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlInvalidateSubFramebuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLenumᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlInvalidateSubFramebuffer) ID() binary.ID {
	return binaryIDGlInvalidateSubFramebuffer
}
func (*binaryClassGlInvalidateSubFramebuffer) New() binary.Object {
	return &GlInvalidateSubFramebuffer{}
}
func (*binaryClassGlInvalidateSubFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlInvalidateSubFramebuffer(e, obj.(*GlInvalidateSubFramebuffer))
}
func (*binaryClassGlInvalidateSubFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlInvalidateSubFramebuffer{}
	return obj, doDecodeGlInvalidateSubFramebuffer(d, obj)
}
func (*binaryClassGlInvalidateSubFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlInvalidateSubFramebuffer(d, obj.(*GlInvalidateSubFramebuffer))
}
func (*binaryClassGlInvalidateSubFramebuffer) Skip(d binary.Decoder) error {
	return doSkipGlInvalidateSubFramebuffer(d)
}
func (*binaryClassGlInvalidateSubFramebuffer) Schema() *schema.Class {
	return schemaGlInvalidateSubFramebuffer
}

var schemaGlInvalidateSubFramebuffer = &schema.Class{
	TypeID:  binaryIDGlInvalidateSubFramebuffer,
	Package: "gles",
	Name:    "GlInvalidateSubFramebuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "NumAttachments", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Attachments", Type: &schema.Struct{Name: "GLenumᶜᵖ", ID: (*GLenumᶜᵖ)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlIsBuffer struct{}

func (*GlIsBuffer) Class() binary.Class {
	return (*binaryClassGlIsBuffer)(nil)
}
func doEncodeGlIsBuffer(e binary.Encoder, o *GlIsBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsBuffer(d binary.Decoder, o *GlIsBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsBuffer) ID() binary.ID      { return binaryIDGlIsBuffer }
func (*binaryClassGlIsBuffer) New() binary.Object { return &GlIsBuffer{} }
func (*binaryClassGlIsBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsBuffer(e, obj.(*GlIsBuffer))
}
func (*binaryClassGlIsBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsBuffer{}
	return obj, doDecodeGlIsBuffer(d, obj)
}
func (*binaryClassGlIsBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsBuffer(d, obj.(*GlIsBuffer))
}
func (*binaryClassGlIsBuffer) Skip(d binary.Decoder) error { return doSkipGlIsBuffer(d) }
func (*binaryClassGlIsBuffer) Schema() *schema.Class       { return schemaGlIsBuffer }

var schemaGlIsBuffer = &schema.Class{
	TypeID:  binaryIDGlIsBuffer,
	Package: "gles",
	Name:    "GlIsBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsEnabled struct{}

func (*GlIsEnabled) Class() binary.Class {
	return (*binaryClassGlIsEnabled)(nil)
}
func doEncodeGlIsEnabled(e binary.Encoder, o *GlIsEnabled) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Capability)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsEnabled(d binary.Decoder, o *GlIsEnabled) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Capability = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsEnabled(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsEnabled) ID() binary.ID      { return binaryIDGlIsEnabled }
func (*binaryClassGlIsEnabled) New() binary.Object { return &GlIsEnabled{} }
func (*binaryClassGlIsEnabled) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsEnabled(e, obj.(*GlIsEnabled))
}
func (*binaryClassGlIsEnabled) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsEnabled{}
	return obj, doDecodeGlIsEnabled(d, obj)
}
func (*binaryClassGlIsEnabled) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsEnabled(d, obj.(*GlIsEnabled))
}
func (*binaryClassGlIsEnabled) Skip(d binary.Decoder) error { return doSkipGlIsEnabled(d) }
func (*binaryClassGlIsEnabled) Schema() *schema.Class       { return schemaGlIsEnabled }

var schemaGlIsEnabled = &schema.Class{
	TypeID:  binaryIDGlIsEnabled,
	Package: "gles",
	Name:    "GlIsEnabled",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Capability", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsEnablediEXT struct{}

func (*GlIsEnablediEXT) Class() binary.Class {
	return (*binaryClassGlIsEnablediEXT)(nil)
}
func doEncodeGlIsEnablediEXT(e binary.Encoder, o *GlIsEnablediEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsEnablediEXT(d binary.Decoder, o *GlIsEnablediEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsEnablediEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsEnablediEXT) ID() binary.ID      { return binaryIDGlIsEnablediEXT }
func (*binaryClassGlIsEnablediEXT) New() binary.Object { return &GlIsEnablediEXT{} }
func (*binaryClassGlIsEnablediEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsEnablediEXT(e, obj.(*GlIsEnablediEXT))
}
func (*binaryClassGlIsEnablediEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsEnablediEXT{}
	return obj, doDecodeGlIsEnablediEXT(d, obj)
}
func (*binaryClassGlIsEnablediEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsEnablediEXT(d, obj.(*GlIsEnablediEXT))
}
func (*binaryClassGlIsEnablediEXT) Skip(d binary.Decoder) error { return doSkipGlIsEnablediEXT(d) }
func (*binaryClassGlIsEnablediEXT) Schema() *schema.Class       { return schemaGlIsEnablediEXT }

var schemaGlIsEnablediEXT = &schema.Class{
	TypeID:  binaryIDGlIsEnablediEXT,
	Package: "gles",
	Name:    "GlIsEnablediEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsEnablediNV struct{}

func (*GlIsEnablediNV) Class() binary.Class {
	return (*binaryClassGlIsEnablediNV)(nil)
}
func doEncodeGlIsEnablediNV(e binary.Encoder, o *GlIsEnablediNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsEnablediNV(d binary.Decoder, o *GlIsEnablediNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsEnablediNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsEnablediNV) ID() binary.ID      { return binaryIDGlIsEnablediNV }
func (*binaryClassGlIsEnablediNV) New() binary.Object { return &GlIsEnablediNV{} }
func (*binaryClassGlIsEnablediNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsEnablediNV(e, obj.(*GlIsEnablediNV))
}
func (*binaryClassGlIsEnablediNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsEnablediNV{}
	return obj, doDecodeGlIsEnablediNV(d, obj)
}
func (*binaryClassGlIsEnablediNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsEnablediNV(d, obj.(*GlIsEnablediNV))
}
func (*binaryClassGlIsEnablediNV) Skip(d binary.Decoder) error { return doSkipGlIsEnablediNV(d) }
func (*binaryClassGlIsEnablediNV) Schema() *schema.Class       { return schemaGlIsEnablediNV }

var schemaGlIsEnablediNV = &schema.Class{
	TypeID:  binaryIDGlIsEnablediNV,
	Package: "gles",
	Name:    "GlIsEnablediNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsEnablediOES struct{}

func (*GlIsEnablediOES) Class() binary.Class {
	return (*binaryClassGlIsEnablediOES)(nil)
}
func doEncodeGlIsEnablediOES(e binary.Encoder, o *GlIsEnablediOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsEnablediOES(d binary.Decoder, o *GlIsEnablediOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsEnablediOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsEnablediOES) ID() binary.ID      { return binaryIDGlIsEnablediOES }
func (*binaryClassGlIsEnablediOES) New() binary.Object { return &GlIsEnablediOES{} }
func (*binaryClassGlIsEnablediOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsEnablediOES(e, obj.(*GlIsEnablediOES))
}
func (*binaryClassGlIsEnablediOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsEnablediOES{}
	return obj, doDecodeGlIsEnablediOES(d, obj)
}
func (*binaryClassGlIsEnablediOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsEnablediOES(d, obj.(*GlIsEnablediOES))
}
func (*binaryClassGlIsEnablediOES) Skip(d binary.Decoder) error { return doSkipGlIsEnablediOES(d) }
func (*binaryClassGlIsEnablediOES) Schema() *schema.Class       { return schemaGlIsEnablediOES }

var schemaGlIsEnablediOES = &schema.Class{
	TypeID:  binaryIDGlIsEnablediOES,
	Package: "gles",
	Name:    "GlIsEnablediOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsFenceNV struct{}

func (*GlIsFenceNV) Class() binary.Class {
	return (*binaryClassGlIsFenceNV)(nil)
}
func doEncodeGlIsFenceNV(e binary.Encoder, o *GlIsFenceNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fence)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsFenceNV(d binary.Decoder, o *GlIsFenceNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fence = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsFenceNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsFenceNV) ID() binary.ID      { return binaryIDGlIsFenceNV }
func (*binaryClassGlIsFenceNV) New() binary.Object { return &GlIsFenceNV{} }
func (*binaryClassGlIsFenceNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsFenceNV(e, obj.(*GlIsFenceNV))
}
func (*binaryClassGlIsFenceNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsFenceNV{}
	return obj, doDecodeGlIsFenceNV(d, obj)
}
func (*binaryClassGlIsFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsFenceNV(d, obj.(*GlIsFenceNV))
}
func (*binaryClassGlIsFenceNV) Skip(d binary.Decoder) error { return doSkipGlIsFenceNV(d) }
func (*binaryClassGlIsFenceNV) Schema() *schema.Class       { return schemaGlIsFenceNV }

var schemaGlIsFenceNV = &schema.Class{
	TypeID:  binaryIDGlIsFenceNV,
	Package: "gles",
	Name:    "GlIsFenceNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsFramebuffer struct{}

func (*GlIsFramebuffer) Class() binary.Class {
	return (*binaryClassGlIsFramebuffer)(nil)
}
func doEncodeGlIsFramebuffer(e binary.Encoder, o *GlIsFramebuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Framebuffer)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsFramebuffer(d binary.Decoder, o *GlIsFramebuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Framebuffer = FramebufferId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsFramebuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsFramebuffer) ID() binary.ID      { return binaryIDGlIsFramebuffer }
func (*binaryClassGlIsFramebuffer) New() binary.Object { return &GlIsFramebuffer{} }
func (*binaryClassGlIsFramebuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsFramebuffer(e, obj.(*GlIsFramebuffer))
}
func (*binaryClassGlIsFramebuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsFramebuffer{}
	return obj, doDecodeGlIsFramebuffer(d, obj)
}
func (*binaryClassGlIsFramebuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsFramebuffer(d, obj.(*GlIsFramebuffer))
}
func (*binaryClassGlIsFramebuffer) Skip(d binary.Decoder) error { return doSkipGlIsFramebuffer(d) }
func (*binaryClassGlIsFramebuffer) Schema() *schema.Class       { return schemaGlIsFramebuffer }

var schemaGlIsFramebuffer = &schema.Class{
	TypeID:  binaryIDGlIsFramebuffer,
	Package: "gles",
	Name:    "GlIsFramebuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsImageHandleResidentNV struct{}

func (*GlIsImageHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlIsImageHandleResidentNV)(nil)
}
func doEncodeGlIsImageHandleResidentNV(e binary.Encoder, o *GlIsImageHandleResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsImageHandleResidentNV(d binary.Decoder, o *GlIsImageHandleResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsImageHandleResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsImageHandleResidentNV) ID() binary.ID      { return binaryIDGlIsImageHandleResidentNV }
func (*binaryClassGlIsImageHandleResidentNV) New() binary.Object { return &GlIsImageHandleResidentNV{} }
func (*binaryClassGlIsImageHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsImageHandleResidentNV(e, obj.(*GlIsImageHandleResidentNV))
}
func (*binaryClassGlIsImageHandleResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsImageHandleResidentNV{}
	return obj, doDecodeGlIsImageHandleResidentNV(d, obj)
}
func (*binaryClassGlIsImageHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsImageHandleResidentNV(d, obj.(*GlIsImageHandleResidentNV))
}
func (*binaryClassGlIsImageHandleResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlIsImageHandleResidentNV(d)
}
func (*binaryClassGlIsImageHandleResidentNV) Schema() *schema.Class {
	return schemaGlIsImageHandleResidentNV
}

var schemaGlIsImageHandleResidentNV = &schema.Class{
	TypeID:  binaryIDGlIsImageHandleResidentNV,
	Package: "gles",
	Name:    "GlIsImageHandleResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsPathNV struct{}

func (*GlIsPathNV) Class() binary.Class {
	return (*binaryClassGlIsPathNV)(nil)
}
func doEncodeGlIsPathNV(e binary.Encoder, o *GlIsPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsPathNV(d binary.Decoder, o *GlIsPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsPathNV) ID() binary.ID      { return binaryIDGlIsPathNV }
func (*binaryClassGlIsPathNV) New() binary.Object { return &GlIsPathNV{} }
func (*binaryClassGlIsPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsPathNV(e, obj.(*GlIsPathNV))
}
func (*binaryClassGlIsPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsPathNV{}
	return obj, doDecodeGlIsPathNV(d, obj)
}
func (*binaryClassGlIsPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsPathNV(d, obj.(*GlIsPathNV))
}
func (*binaryClassGlIsPathNV) Skip(d binary.Decoder) error { return doSkipGlIsPathNV(d) }
func (*binaryClassGlIsPathNV) Schema() *schema.Class       { return schemaGlIsPathNV }

var schemaGlIsPathNV = &schema.Class{
	TypeID:  binaryIDGlIsPathNV,
	Package: "gles",
	Name:    "GlIsPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsPointInFillPathNV struct{}

func (*GlIsPointInFillPathNV) Class() binary.Class {
	return (*binaryClassGlIsPointInFillPathNV)(nil)
}
func doEncodeGlIsPointInFillPathNV(e binary.Encoder, o *GlIsPointInFillPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.X)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Y)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsPointInFillPathNV(d binary.Decoder, o *GlIsPointInFillPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.X = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Y = GLfloat(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsPointInFillPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsPointInFillPathNV) ID() binary.ID      { return binaryIDGlIsPointInFillPathNV }
func (*binaryClassGlIsPointInFillPathNV) New() binary.Object { return &GlIsPointInFillPathNV{} }
func (*binaryClassGlIsPointInFillPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsPointInFillPathNV(e, obj.(*GlIsPointInFillPathNV))
}
func (*binaryClassGlIsPointInFillPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsPointInFillPathNV{}
	return obj, doDecodeGlIsPointInFillPathNV(d, obj)
}
func (*binaryClassGlIsPointInFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsPointInFillPathNV(d, obj.(*GlIsPointInFillPathNV))
}
func (*binaryClassGlIsPointInFillPathNV) Skip(d binary.Decoder) error {
	return doSkipGlIsPointInFillPathNV(d)
}
func (*binaryClassGlIsPointInFillPathNV) Schema() *schema.Class { return schemaGlIsPointInFillPathNV }

var schemaGlIsPointInFillPathNV = &schema.Class{
	TypeID:  binaryIDGlIsPointInFillPathNV,
	Package: "gles",
	Name:    "GlIsPointInFillPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsPointInStrokePathNV struct{}

func (*GlIsPointInStrokePathNV) Class() binary.Class {
	return (*binaryClassGlIsPointInStrokePathNV)(nil)
}
func doEncodeGlIsPointInStrokePathNV(e binary.Encoder, o *GlIsPointInStrokePathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.X)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Y)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsPointInStrokePathNV(d binary.Decoder, o *GlIsPointInStrokePathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.X = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Y = GLfloat(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsPointInStrokePathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsPointInStrokePathNV) ID() binary.ID      { return binaryIDGlIsPointInStrokePathNV }
func (*binaryClassGlIsPointInStrokePathNV) New() binary.Object { return &GlIsPointInStrokePathNV{} }
func (*binaryClassGlIsPointInStrokePathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsPointInStrokePathNV(e, obj.(*GlIsPointInStrokePathNV))
}
func (*binaryClassGlIsPointInStrokePathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsPointInStrokePathNV{}
	return obj, doDecodeGlIsPointInStrokePathNV(d, obj)
}
func (*binaryClassGlIsPointInStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsPointInStrokePathNV(d, obj.(*GlIsPointInStrokePathNV))
}
func (*binaryClassGlIsPointInStrokePathNV) Skip(d binary.Decoder) error {
	return doSkipGlIsPointInStrokePathNV(d)
}
func (*binaryClassGlIsPointInStrokePathNV) Schema() *schema.Class {
	return schemaGlIsPointInStrokePathNV
}

var schemaGlIsPointInStrokePathNV = &schema.Class{
	TypeID:  binaryIDGlIsPointInStrokePathNV,
	Package: "gles",
	Name:    "GlIsPointInStrokePathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsProgram struct{}

func (*GlIsProgram) Class() binary.Class {
	return (*binaryClassGlIsProgram)(nil)
}
func doEncodeGlIsProgram(e binary.Encoder, o *GlIsProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsProgram(d binary.Decoder, o *GlIsProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsProgram) ID() binary.ID      { return binaryIDGlIsProgram }
func (*binaryClassGlIsProgram) New() binary.Object { return &GlIsProgram{} }
func (*binaryClassGlIsProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsProgram(e, obj.(*GlIsProgram))
}
func (*binaryClassGlIsProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsProgram{}
	return obj, doDecodeGlIsProgram(d, obj)
}
func (*binaryClassGlIsProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsProgram(d, obj.(*GlIsProgram))
}
func (*binaryClassGlIsProgram) Skip(d binary.Decoder) error { return doSkipGlIsProgram(d) }
func (*binaryClassGlIsProgram) Schema() *schema.Class       { return schemaGlIsProgram }

var schemaGlIsProgram = &schema.Class{
	TypeID:  binaryIDGlIsProgram,
	Package: "gles",
	Name:    "GlIsProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsProgramPipeline struct{}

func (*GlIsProgramPipeline) Class() binary.Class {
	return (*binaryClassGlIsProgramPipeline)(nil)
}
func doEncodeGlIsProgramPipeline(e binary.Encoder, o *GlIsProgramPipeline) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsProgramPipeline(d binary.Decoder, o *GlIsProgramPipeline) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsProgramPipeline(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsProgramPipeline) ID() binary.ID      { return binaryIDGlIsProgramPipeline }
func (*binaryClassGlIsProgramPipeline) New() binary.Object { return &GlIsProgramPipeline{} }
func (*binaryClassGlIsProgramPipeline) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsProgramPipeline(e, obj.(*GlIsProgramPipeline))
}
func (*binaryClassGlIsProgramPipeline) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsProgramPipeline{}
	return obj, doDecodeGlIsProgramPipeline(d, obj)
}
func (*binaryClassGlIsProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsProgramPipeline(d, obj.(*GlIsProgramPipeline))
}
func (*binaryClassGlIsProgramPipeline) Skip(d binary.Decoder) error {
	return doSkipGlIsProgramPipeline(d)
}
func (*binaryClassGlIsProgramPipeline) Schema() *schema.Class { return schemaGlIsProgramPipeline }

var schemaGlIsProgramPipeline = &schema.Class{
	TypeID:  binaryIDGlIsProgramPipeline,
	Package: "gles",
	Name:    "GlIsProgramPipeline",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsProgramPipelineEXT struct{}

func (*GlIsProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlIsProgramPipelineEXT)(nil)
}
func doEncodeGlIsProgramPipelineEXT(e binary.Encoder, o *GlIsProgramPipelineEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsProgramPipelineEXT(d binary.Decoder, o *GlIsProgramPipelineEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsProgramPipelineEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsProgramPipelineEXT) ID() binary.ID      { return binaryIDGlIsProgramPipelineEXT }
func (*binaryClassGlIsProgramPipelineEXT) New() binary.Object { return &GlIsProgramPipelineEXT{} }
func (*binaryClassGlIsProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsProgramPipelineEXT(e, obj.(*GlIsProgramPipelineEXT))
}
func (*binaryClassGlIsProgramPipelineEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsProgramPipelineEXT{}
	return obj, doDecodeGlIsProgramPipelineEXT(d, obj)
}
func (*binaryClassGlIsProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsProgramPipelineEXT(d, obj.(*GlIsProgramPipelineEXT))
}
func (*binaryClassGlIsProgramPipelineEXT) Skip(d binary.Decoder) error {
	return doSkipGlIsProgramPipelineEXT(d)
}
func (*binaryClassGlIsProgramPipelineEXT) Schema() *schema.Class { return schemaGlIsProgramPipelineEXT }

var schemaGlIsProgramPipelineEXT = &schema.Class{
	TypeID:  binaryIDGlIsProgramPipelineEXT,
	Package: "gles",
	Name:    "GlIsProgramPipelineEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsQuery struct{}

func (*GlIsQuery) Class() binary.Class {
	return (*binaryClassGlIsQuery)(nil)
}
func doEncodeGlIsQuery(e binary.Encoder, o *GlIsQuery) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsQuery(d binary.Decoder, o *GlIsQuery) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsQuery(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsQuery) ID() binary.ID      { return binaryIDGlIsQuery }
func (*binaryClassGlIsQuery) New() binary.Object { return &GlIsQuery{} }
func (*binaryClassGlIsQuery) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsQuery(e, obj.(*GlIsQuery))
}
func (*binaryClassGlIsQuery) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsQuery{}
	return obj, doDecodeGlIsQuery(d, obj)
}
func (*binaryClassGlIsQuery) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsQuery(d, obj.(*GlIsQuery))
}
func (*binaryClassGlIsQuery) Skip(d binary.Decoder) error { return doSkipGlIsQuery(d) }
func (*binaryClassGlIsQuery) Schema() *schema.Class       { return schemaGlIsQuery }

var schemaGlIsQuery = &schema.Class{
	TypeID:  binaryIDGlIsQuery,
	Package: "gles",
	Name:    "GlIsQuery",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsQueryEXT struct{}

func (*GlIsQueryEXT) Class() binary.Class {
	return (*binaryClassGlIsQueryEXT)(nil)
}
func doEncodeGlIsQueryEXT(e binary.Encoder, o *GlIsQueryEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsQueryEXT(d binary.Decoder, o *GlIsQueryEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsQueryEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsQueryEXT) ID() binary.ID      { return binaryIDGlIsQueryEXT }
func (*binaryClassGlIsQueryEXT) New() binary.Object { return &GlIsQueryEXT{} }
func (*binaryClassGlIsQueryEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsQueryEXT(e, obj.(*GlIsQueryEXT))
}
func (*binaryClassGlIsQueryEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsQueryEXT{}
	return obj, doDecodeGlIsQueryEXT(d, obj)
}
func (*binaryClassGlIsQueryEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsQueryEXT(d, obj.(*GlIsQueryEXT))
}
func (*binaryClassGlIsQueryEXT) Skip(d binary.Decoder) error { return doSkipGlIsQueryEXT(d) }
func (*binaryClassGlIsQueryEXT) Schema() *schema.Class       { return schemaGlIsQueryEXT }

var schemaGlIsQueryEXT = &schema.Class{
	TypeID:  binaryIDGlIsQueryEXT,
	Package: "gles",
	Name:    "GlIsQueryEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsRenderbuffer struct{}

func (*GlIsRenderbuffer) Class() binary.Class {
	return (*binaryClassGlIsRenderbuffer)(nil)
}
func doEncodeGlIsRenderbuffer(e binary.Encoder, o *GlIsRenderbuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Renderbuffer)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsRenderbuffer(d binary.Decoder, o *GlIsRenderbuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Renderbuffer = RenderbufferId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsRenderbuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsRenderbuffer) ID() binary.ID      { return binaryIDGlIsRenderbuffer }
func (*binaryClassGlIsRenderbuffer) New() binary.Object { return &GlIsRenderbuffer{} }
func (*binaryClassGlIsRenderbuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsRenderbuffer(e, obj.(*GlIsRenderbuffer))
}
func (*binaryClassGlIsRenderbuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsRenderbuffer{}
	return obj, doDecodeGlIsRenderbuffer(d, obj)
}
func (*binaryClassGlIsRenderbuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsRenderbuffer(d, obj.(*GlIsRenderbuffer))
}
func (*binaryClassGlIsRenderbuffer) Skip(d binary.Decoder) error { return doSkipGlIsRenderbuffer(d) }
func (*binaryClassGlIsRenderbuffer) Schema() *schema.Class       { return schemaGlIsRenderbuffer }

var schemaGlIsRenderbuffer = &schema.Class{
	TypeID:  binaryIDGlIsRenderbuffer,
	Package: "gles",
	Name:    "GlIsRenderbuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsSampler struct{}

func (*GlIsSampler) Class() binary.Class {
	return (*binaryClassGlIsSampler)(nil)
}
func doEncodeGlIsSampler(e binary.Encoder, o *GlIsSampler) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsSampler(d binary.Decoder, o *GlIsSampler) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsSampler(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsSampler) ID() binary.ID      { return binaryIDGlIsSampler }
func (*binaryClassGlIsSampler) New() binary.Object { return &GlIsSampler{} }
func (*binaryClassGlIsSampler) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsSampler(e, obj.(*GlIsSampler))
}
func (*binaryClassGlIsSampler) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsSampler{}
	return obj, doDecodeGlIsSampler(d, obj)
}
func (*binaryClassGlIsSampler) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsSampler(d, obj.(*GlIsSampler))
}
func (*binaryClassGlIsSampler) Skip(d binary.Decoder) error { return doSkipGlIsSampler(d) }
func (*binaryClassGlIsSampler) Schema() *schema.Class       { return schemaGlIsSampler }

var schemaGlIsSampler = &schema.Class{
	TypeID:  binaryIDGlIsSampler,
	Package: "gles",
	Name:    "GlIsSampler",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsShader struct{}

func (*GlIsShader) Class() binary.Class {
	return (*binaryClassGlIsShader)(nil)
}
func doEncodeGlIsShader(e binary.Encoder, o *GlIsShader) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsShader(d binary.Decoder, o *GlIsShader) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsShader(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsShader) ID() binary.ID      { return binaryIDGlIsShader }
func (*binaryClassGlIsShader) New() binary.Object { return &GlIsShader{} }
func (*binaryClassGlIsShader) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsShader(e, obj.(*GlIsShader))
}
func (*binaryClassGlIsShader) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsShader{}
	return obj, doDecodeGlIsShader(d, obj)
}
func (*binaryClassGlIsShader) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsShader(d, obj.(*GlIsShader))
}
func (*binaryClassGlIsShader) Skip(d binary.Decoder) error { return doSkipGlIsShader(d) }
func (*binaryClassGlIsShader) Schema() *schema.Class       { return schemaGlIsShader }

var schemaGlIsShader = &schema.Class{
	TypeID:  binaryIDGlIsShader,
	Package: "gles",
	Name:    "GlIsShader",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsSync struct{}

func (*GlIsSync) Class() binary.Class {
	return (*binaryClassGlIsSync)(nil)
}
func doEncodeGlIsSync(e binary.Encoder, o *GlIsSync) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsSync(d binary.Decoder, o *GlIsSync) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsSync(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsSync) ID() binary.ID      { return binaryIDGlIsSync }
func (*binaryClassGlIsSync) New() binary.Object { return &GlIsSync{} }
func (*binaryClassGlIsSync) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsSync(e, obj.(*GlIsSync))
}
func (*binaryClassGlIsSync) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsSync{}
	return obj, doDecodeGlIsSync(d, obj)
}
func (*binaryClassGlIsSync) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsSync(d, obj.(*GlIsSync))
}
func (*binaryClassGlIsSync) Skip(d binary.Decoder) error { return doSkipGlIsSync(d) }
func (*binaryClassGlIsSync) Schema() *schema.Class       { return schemaGlIsSync }

var schemaGlIsSync = &schema.Class{
	TypeID:  binaryIDGlIsSync,
	Package: "gles",
	Name:    "GlIsSync",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsSyncAPPLE struct{}

func (*GlIsSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlIsSyncAPPLE)(nil)
}
func doEncodeGlIsSyncAPPLE(e binary.Encoder, o *GlIsSyncAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsSyncAPPLE(d binary.Decoder, o *GlIsSyncAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsSyncAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsSyncAPPLE) ID() binary.ID      { return binaryIDGlIsSyncAPPLE }
func (*binaryClassGlIsSyncAPPLE) New() binary.Object { return &GlIsSyncAPPLE{} }
func (*binaryClassGlIsSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsSyncAPPLE(e, obj.(*GlIsSyncAPPLE))
}
func (*binaryClassGlIsSyncAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsSyncAPPLE{}
	return obj, doDecodeGlIsSyncAPPLE(d, obj)
}
func (*binaryClassGlIsSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsSyncAPPLE(d, obj.(*GlIsSyncAPPLE))
}
func (*binaryClassGlIsSyncAPPLE) Skip(d binary.Decoder) error { return doSkipGlIsSyncAPPLE(d) }
func (*binaryClassGlIsSyncAPPLE) Schema() *schema.Class       { return schemaGlIsSyncAPPLE }

var schemaGlIsSyncAPPLE = &schema.Class{
	TypeID:  binaryIDGlIsSyncAPPLE,
	Package: "gles",
	Name:    "GlIsSyncAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsTexture struct{}

func (*GlIsTexture) Class() binary.Class {
	return (*binaryClassGlIsTexture)(nil)
}
func doEncodeGlIsTexture(e binary.Encoder, o *GlIsTexture) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsTexture(d binary.Decoder, o *GlIsTexture) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsTexture(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsTexture) ID() binary.ID      { return binaryIDGlIsTexture }
func (*binaryClassGlIsTexture) New() binary.Object { return &GlIsTexture{} }
func (*binaryClassGlIsTexture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsTexture(e, obj.(*GlIsTexture))
}
func (*binaryClassGlIsTexture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsTexture{}
	return obj, doDecodeGlIsTexture(d, obj)
}
func (*binaryClassGlIsTexture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsTexture(d, obj.(*GlIsTexture))
}
func (*binaryClassGlIsTexture) Skip(d binary.Decoder) error { return doSkipGlIsTexture(d) }
func (*binaryClassGlIsTexture) Schema() *schema.Class       { return schemaGlIsTexture }

var schemaGlIsTexture = &schema.Class{
	TypeID:  binaryIDGlIsTexture,
	Package: "gles",
	Name:    "GlIsTexture",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsTextureHandleResidentNV struct{}

func (*GlIsTextureHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlIsTextureHandleResidentNV)(nil)
}
func doEncodeGlIsTextureHandleResidentNV(e binary.Encoder, o *GlIsTextureHandleResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsTextureHandleResidentNV(d binary.Decoder, o *GlIsTextureHandleResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsTextureHandleResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsTextureHandleResidentNV) ID() binary.ID {
	return binaryIDGlIsTextureHandleResidentNV
}
func (*binaryClassGlIsTextureHandleResidentNV) New() binary.Object {
	return &GlIsTextureHandleResidentNV{}
}
func (*binaryClassGlIsTextureHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsTextureHandleResidentNV(e, obj.(*GlIsTextureHandleResidentNV))
}
func (*binaryClassGlIsTextureHandleResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsTextureHandleResidentNV{}
	return obj, doDecodeGlIsTextureHandleResidentNV(d, obj)
}
func (*binaryClassGlIsTextureHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsTextureHandleResidentNV(d, obj.(*GlIsTextureHandleResidentNV))
}
func (*binaryClassGlIsTextureHandleResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlIsTextureHandleResidentNV(d)
}
func (*binaryClassGlIsTextureHandleResidentNV) Schema() *schema.Class {
	return schemaGlIsTextureHandleResidentNV
}

var schemaGlIsTextureHandleResidentNV = &schema.Class{
	TypeID:  binaryIDGlIsTextureHandleResidentNV,
	Package: "gles",
	Name:    "GlIsTextureHandleResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsTransformFeedback struct{}

func (*GlIsTransformFeedback) Class() binary.Class {
	return (*binaryClassGlIsTransformFeedback)(nil)
}
func doEncodeGlIsTransformFeedback(e binary.Encoder, o *GlIsTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Id)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsTransformFeedback(d binary.Decoder, o *GlIsTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = TransformFeedbackId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsTransformFeedback) ID() binary.ID      { return binaryIDGlIsTransformFeedback }
func (*binaryClassGlIsTransformFeedback) New() binary.Object { return &GlIsTransformFeedback{} }
func (*binaryClassGlIsTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsTransformFeedback(e, obj.(*GlIsTransformFeedback))
}
func (*binaryClassGlIsTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsTransformFeedback{}
	return obj, doDecodeGlIsTransformFeedback(d, obj)
}
func (*binaryClassGlIsTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsTransformFeedback(d, obj.(*GlIsTransformFeedback))
}
func (*binaryClassGlIsTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlIsTransformFeedback(d)
}
func (*binaryClassGlIsTransformFeedback) Schema() *schema.Class { return schemaGlIsTransformFeedback }

var schemaGlIsTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlIsTransformFeedback,
	Package: "gles",
	Name:    "GlIsTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Id", Type: &schema.Primitive{Name: "TransformFeedbackId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsVertexArray struct{}

func (*GlIsVertexArray) Class() binary.Class {
	return (*binaryClassGlIsVertexArray)(nil)
}
func doEncodeGlIsVertexArray(e binary.Encoder, o *GlIsVertexArray) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Array)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsVertexArray(d binary.Decoder, o *GlIsVertexArray) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Array = VertexArrayId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsVertexArray(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsVertexArray) ID() binary.ID      { return binaryIDGlIsVertexArray }
func (*binaryClassGlIsVertexArray) New() binary.Object { return &GlIsVertexArray{} }
func (*binaryClassGlIsVertexArray) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsVertexArray(e, obj.(*GlIsVertexArray))
}
func (*binaryClassGlIsVertexArray) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsVertexArray{}
	return obj, doDecodeGlIsVertexArray(d, obj)
}
func (*binaryClassGlIsVertexArray) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsVertexArray(d, obj.(*GlIsVertexArray))
}
func (*binaryClassGlIsVertexArray) Skip(d binary.Decoder) error { return doSkipGlIsVertexArray(d) }
func (*binaryClassGlIsVertexArray) Schema() *schema.Class       { return schemaGlIsVertexArray }

var schemaGlIsVertexArray = &schema.Class{
	TypeID:  binaryIDGlIsVertexArray,
	Package: "gles",
	Name:    "GlIsVertexArray",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlIsVertexArrayOES struct{}

func (*GlIsVertexArrayOES) Class() binary.Class {
	return (*binaryClassGlIsVertexArrayOES)(nil)
}
func doEncodeGlIsVertexArrayOES(e binary.Encoder, o *GlIsVertexArrayOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Array)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlIsVertexArrayOES(d binary.Decoder, o *GlIsVertexArrayOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Array = VertexArrayId(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlIsVertexArrayOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlIsVertexArrayOES) ID() binary.ID      { return binaryIDGlIsVertexArrayOES }
func (*binaryClassGlIsVertexArrayOES) New() binary.Object { return &GlIsVertexArrayOES{} }
func (*binaryClassGlIsVertexArrayOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlIsVertexArrayOES(e, obj.(*GlIsVertexArrayOES))
}
func (*binaryClassGlIsVertexArrayOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlIsVertexArrayOES{}
	return obj, doDecodeGlIsVertexArrayOES(d, obj)
}
func (*binaryClassGlIsVertexArrayOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlIsVertexArrayOES(d, obj.(*GlIsVertexArrayOES))
}
func (*binaryClassGlIsVertexArrayOES) Skip(d binary.Decoder) error { return doSkipGlIsVertexArrayOES(d) }
func (*binaryClassGlIsVertexArrayOES) Schema() *schema.Class       { return schemaGlIsVertexArrayOES }

var schemaGlIsVertexArrayOES = &schema.Class{
	TypeID:  binaryIDGlIsVertexArrayOES,
	Package: "gles",
	Name:    "GlIsVertexArrayOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlLabelObjectEXT struct{}

func (*GlLabelObjectEXT) Class() binary.Class {
	return (*binaryClassGlLabelObjectEXT)(nil)
}
func doEncodeGlLabelObjectEXT(e binary.Encoder, o *GlLabelObjectEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Object)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlLabelObjectEXT(d binary.Decoder, o *GlLabelObjectEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Object = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlLabelObjectEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlLabelObjectEXT) ID() binary.ID      { return binaryIDGlLabelObjectEXT }
func (*binaryClassGlLabelObjectEXT) New() binary.Object { return &GlLabelObjectEXT{} }
func (*binaryClassGlLabelObjectEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlLabelObjectEXT(e, obj.(*GlLabelObjectEXT))
}
func (*binaryClassGlLabelObjectEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlLabelObjectEXT{}
	return obj, doDecodeGlLabelObjectEXT(d, obj)
}
func (*binaryClassGlLabelObjectEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlLabelObjectEXT(d, obj.(*GlLabelObjectEXT))
}
func (*binaryClassGlLabelObjectEXT) Skip(d binary.Decoder) error { return doSkipGlLabelObjectEXT(d) }
func (*binaryClassGlLabelObjectEXT) Schema() *schema.Class       { return schemaGlLabelObjectEXT }

var schemaGlLabelObjectEXT = &schema.Class{
	TypeID:  binaryIDGlLabelObjectEXT,
	Package: "gles",
	Name:    "GlLabelObjectEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Object", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlLineWidth struct{}

func (*GlLineWidth) Class() binary.Class {
	return (*binaryClassGlLineWidth)(nil)
}
func doEncodeGlLineWidth(e binary.Encoder, o *GlLineWidth) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Width)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlLineWidth(d binary.Decoder, o *GlLineWidth) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Width = GLfloat(obj)
	}
	return nil
}
func doSkipGlLineWidth(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlLineWidth) ID() binary.ID      { return binaryIDGlLineWidth }
func (*binaryClassGlLineWidth) New() binary.Object { return &GlLineWidth{} }
func (*binaryClassGlLineWidth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlLineWidth(e, obj.(*GlLineWidth))
}
func (*binaryClassGlLineWidth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlLineWidth{}
	return obj, doDecodeGlLineWidth(d, obj)
}
func (*binaryClassGlLineWidth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlLineWidth(d, obj.(*GlLineWidth))
}
func (*binaryClassGlLineWidth) Skip(d binary.Decoder) error { return doSkipGlLineWidth(d) }
func (*binaryClassGlLineWidth) Schema() *schema.Class       { return schemaGlLineWidth }

var schemaGlLineWidth = &schema.Class{
	TypeID:  binaryIDGlLineWidth,
	Package: "gles",
	Name:    "GlLineWidth",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlLinkProgram struct{}

func (*GlLinkProgram) Class() binary.Class {
	return (*binaryClassGlLinkProgram)(nil)
}
func doEncodeGlLinkProgram(e binary.Encoder, o *GlLinkProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlLinkProgram(d binary.Decoder, o *GlLinkProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlLinkProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlLinkProgram) ID() binary.ID      { return binaryIDGlLinkProgram }
func (*binaryClassGlLinkProgram) New() binary.Object { return &GlLinkProgram{} }
func (*binaryClassGlLinkProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlLinkProgram(e, obj.(*GlLinkProgram))
}
func (*binaryClassGlLinkProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlLinkProgram{}
	return obj, doDecodeGlLinkProgram(d, obj)
}
func (*binaryClassGlLinkProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlLinkProgram(d, obj.(*GlLinkProgram))
}
func (*binaryClassGlLinkProgram) Skip(d binary.Decoder) error { return doSkipGlLinkProgram(d) }
func (*binaryClassGlLinkProgram) Schema() *schema.Class       { return schemaGlLinkProgram }

var schemaGlLinkProgram = &schema.Class{
	TypeID:  binaryIDGlLinkProgram,
	Package: "gles",
	Name:    "GlLinkProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlMakeImageHandleNonResidentNV struct{}

func (*GlMakeImageHandleNonResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeImageHandleNonResidentNV)(nil)
}
func doEncodeGlMakeImageHandleNonResidentNV(e binary.Encoder, o *GlMakeImageHandleNonResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMakeImageHandleNonResidentNV(d binary.Decoder, o *GlMakeImageHandleNonResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	return nil
}
func doSkipGlMakeImageHandleNonResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMakeImageHandleNonResidentNV) ID() binary.ID {
	return binaryIDGlMakeImageHandleNonResidentNV
}
func (*binaryClassGlMakeImageHandleNonResidentNV) New() binary.Object {
	return &GlMakeImageHandleNonResidentNV{}
}
func (*binaryClassGlMakeImageHandleNonResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMakeImageHandleNonResidentNV(e, obj.(*GlMakeImageHandleNonResidentNV))
}
func (*binaryClassGlMakeImageHandleNonResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMakeImageHandleNonResidentNV{}
	return obj, doDecodeGlMakeImageHandleNonResidentNV(d, obj)
}
func (*binaryClassGlMakeImageHandleNonResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMakeImageHandleNonResidentNV(d, obj.(*GlMakeImageHandleNonResidentNV))
}
func (*binaryClassGlMakeImageHandleNonResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlMakeImageHandleNonResidentNV(d)
}
func (*binaryClassGlMakeImageHandleNonResidentNV) Schema() *schema.Class {
	return schemaGlMakeImageHandleNonResidentNV
}

var schemaGlMakeImageHandleNonResidentNV = &schema.Class{
	TypeID:  binaryIDGlMakeImageHandleNonResidentNV,
	Package: "gles",
	Name:    "GlMakeImageHandleNonResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlMakeImageHandleResidentNV struct{}

func (*GlMakeImageHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeImageHandleResidentNV)(nil)
}
func doEncodeGlMakeImageHandleResidentNV(e binary.Encoder, o *GlMakeImageHandleResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Access)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMakeImageHandleResidentNV(d binary.Decoder, o *GlMakeImageHandleResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Access = GLenum(obj)
	}
	return nil
}
func doSkipGlMakeImageHandleResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMakeImageHandleResidentNV) ID() binary.ID {
	return binaryIDGlMakeImageHandleResidentNV
}
func (*binaryClassGlMakeImageHandleResidentNV) New() binary.Object {
	return &GlMakeImageHandleResidentNV{}
}
func (*binaryClassGlMakeImageHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMakeImageHandleResidentNV(e, obj.(*GlMakeImageHandleResidentNV))
}
func (*binaryClassGlMakeImageHandleResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMakeImageHandleResidentNV{}
	return obj, doDecodeGlMakeImageHandleResidentNV(d, obj)
}
func (*binaryClassGlMakeImageHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMakeImageHandleResidentNV(d, obj.(*GlMakeImageHandleResidentNV))
}
func (*binaryClassGlMakeImageHandleResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlMakeImageHandleResidentNV(d)
}
func (*binaryClassGlMakeImageHandleResidentNV) Schema() *schema.Class {
	return schemaGlMakeImageHandleResidentNV
}

var schemaGlMakeImageHandleResidentNV = &schema.Class{
	TypeID:  binaryIDGlMakeImageHandleResidentNV,
	Package: "gles",
	Name:    "GlMakeImageHandleResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
		{Declared: "Access", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlMakeTextureHandleNonResidentNV struct{}

func (*GlMakeTextureHandleNonResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeTextureHandleNonResidentNV)(nil)
}
func doEncodeGlMakeTextureHandleNonResidentNV(e binary.Encoder, o *GlMakeTextureHandleNonResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMakeTextureHandleNonResidentNV(d binary.Decoder, o *GlMakeTextureHandleNonResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	return nil
}
func doSkipGlMakeTextureHandleNonResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) ID() binary.ID {
	return binaryIDGlMakeTextureHandleNonResidentNV
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) New() binary.Object {
	return &GlMakeTextureHandleNonResidentNV{}
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMakeTextureHandleNonResidentNV(e, obj.(*GlMakeTextureHandleNonResidentNV))
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMakeTextureHandleNonResidentNV{}
	return obj, doDecodeGlMakeTextureHandleNonResidentNV(d, obj)
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMakeTextureHandleNonResidentNV(d, obj.(*GlMakeTextureHandleNonResidentNV))
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlMakeTextureHandleNonResidentNV(d)
}
func (*binaryClassGlMakeTextureHandleNonResidentNV) Schema() *schema.Class {
	return schemaGlMakeTextureHandleNonResidentNV
}

var schemaGlMakeTextureHandleNonResidentNV = &schema.Class{
	TypeID:  binaryIDGlMakeTextureHandleNonResidentNV,
	Package: "gles",
	Name:    "GlMakeTextureHandleNonResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlMakeTextureHandleResidentNV struct{}

func (*GlMakeTextureHandleResidentNV) Class() binary.Class {
	return (*binaryClassGlMakeTextureHandleResidentNV)(nil)
}
func doEncodeGlMakeTextureHandleResidentNV(e binary.Encoder, o *GlMakeTextureHandleResidentNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Handle)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMakeTextureHandleResidentNV(d binary.Decoder, o *GlMakeTextureHandleResidentNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Handle = GLuint64(obj)
	}
	return nil
}
func doSkipGlMakeTextureHandleResidentNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMakeTextureHandleResidentNV) ID() binary.ID {
	return binaryIDGlMakeTextureHandleResidentNV
}
func (*binaryClassGlMakeTextureHandleResidentNV) New() binary.Object {
	return &GlMakeTextureHandleResidentNV{}
}
func (*binaryClassGlMakeTextureHandleResidentNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMakeTextureHandleResidentNV(e, obj.(*GlMakeTextureHandleResidentNV))
}
func (*binaryClassGlMakeTextureHandleResidentNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMakeTextureHandleResidentNV{}
	return obj, doDecodeGlMakeTextureHandleResidentNV(d, obj)
}
func (*binaryClassGlMakeTextureHandleResidentNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMakeTextureHandleResidentNV(d, obj.(*GlMakeTextureHandleResidentNV))
}
func (*binaryClassGlMakeTextureHandleResidentNV) Skip(d binary.Decoder) error {
	return doSkipGlMakeTextureHandleResidentNV(d)
}
func (*binaryClassGlMakeTextureHandleResidentNV) Schema() *schema.Class {
	return schemaGlMakeTextureHandleResidentNV
}

var schemaGlMakeTextureHandleResidentNV = &schema.Class{
	TypeID:  binaryIDGlMakeTextureHandleResidentNV,
	Package: "gles",
	Name:    "GlMakeTextureHandleResidentNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlMapBufferOES struct{}

func (*GlMapBufferOES) Class() binary.Class {
	return (*binaryClassGlMapBufferOES)(nil)
}
func doEncodeGlMapBufferOES(e binary.Encoder, o *GlMapBufferOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Access)); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMapBufferOES(d binary.Decoder, o *GlMapBufferOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Access = GLenum(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlMapBufferOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMapBufferOES) ID() binary.ID      { return binaryIDGlMapBufferOES }
func (*binaryClassGlMapBufferOES) New() binary.Object { return &GlMapBufferOES{} }
func (*binaryClassGlMapBufferOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMapBufferOES(e, obj.(*GlMapBufferOES))
}
func (*binaryClassGlMapBufferOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMapBufferOES{}
	return obj, doDecodeGlMapBufferOES(d, obj)
}
func (*binaryClassGlMapBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMapBufferOES(d, obj.(*GlMapBufferOES))
}
func (*binaryClassGlMapBufferOES) Skip(d binary.Decoder) error { return doSkipGlMapBufferOES(d) }
func (*binaryClassGlMapBufferOES) Schema() *schema.Class       { return schemaGlMapBufferOES }

var schemaGlMapBufferOES = &schema.Class{
	TypeID:  binaryIDGlMapBufferOES,
	Package: "gles",
	Name:    "GlMapBufferOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Access", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMapBufferRange struct{}

func (*GlMapBufferRange) Class() binary.Class {
	return (*binaryClassGlMapBufferRange)(nil)
}
func doEncodeGlMapBufferRange(e binary.Encoder, o *GlMapBufferRange) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Access)); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMapBufferRange(d binary.Decoder, o *GlMapBufferRange) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizeiptr(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Access = GLbitfield(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlMapBufferRange(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMapBufferRange) ID() binary.ID      { return binaryIDGlMapBufferRange }
func (*binaryClassGlMapBufferRange) New() binary.Object { return &GlMapBufferRange{} }
func (*binaryClassGlMapBufferRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMapBufferRange(e, obj.(*GlMapBufferRange))
}
func (*binaryClassGlMapBufferRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMapBufferRange{}
	return obj, doDecodeGlMapBufferRange(d, obj)
}
func (*binaryClassGlMapBufferRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMapBufferRange(d, obj.(*GlMapBufferRange))
}
func (*binaryClassGlMapBufferRange) Skip(d binary.Decoder) error { return doSkipGlMapBufferRange(d) }
func (*binaryClassGlMapBufferRange) Schema() *schema.Class       { return schemaGlMapBufferRange }

var schemaGlMapBufferRange = &schema.Class{
	TypeID:  binaryIDGlMapBufferRange,
	Package: "gles",
	Name:    "GlMapBufferRange",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Access", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMapBufferRangeEXT struct{}

func (*GlMapBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlMapBufferRangeEXT)(nil)
}
func doEncodeGlMapBufferRangeEXT(e binary.Encoder, o *GlMapBufferRangeEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Access)); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMapBufferRangeEXT(d binary.Decoder, o *GlMapBufferRangeEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizeiptr(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Access = GLbitfield(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlMapBufferRangeEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMapBufferRangeEXT) ID() binary.ID      { return binaryIDGlMapBufferRangeEXT }
func (*binaryClassGlMapBufferRangeEXT) New() binary.Object { return &GlMapBufferRangeEXT{} }
func (*binaryClassGlMapBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMapBufferRangeEXT(e, obj.(*GlMapBufferRangeEXT))
}
func (*binaryClassGlMapBufferRangeEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMapBufferRangeEXT{}
	return obj, doDecodeGlMapBufferRangeEXT(d, obj)
}
func (*binaryClassGlMapBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMapBufferRangeEXT(d, obj.(*GlMapBufferRangeEXT))
}
func (*binaryClassGlMapBufferRangeEXT) Skip(d binary.Decoder) error {
	return doSkipGlMapBufferRangeEXT(d)
}
func (*binaryClassGlMapBufferRangeEXT) Schema() *schema.Class { return schemaGlMapBufferRangeEXT }

var schemaGlMapBufferRangeEXT = &schema.Class{
	TypeID:  binaryIDGlMapBufferRangeEXT,
	Package: "gles",
	Name:    "GlMapBufferRangeEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "Access", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixLoad3x2fNV struct{}

func (*GlMatrixLoad3x2fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoad3x2fNV)(nil)
}
func doEncodeGlMatrixLoad3x2fNV(e binary.Encoder, o *GlMatrixLoad3x2fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixLoad3x2fNV(d binary.Decoder, o *GlMatrixLoad3x2fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixLoad3x2fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixLoad3x2fNV) ID() binary.ID      { return binaryIDGlMatrixLoad3x2fNV }
func (*binaryClassGlMatrixLoad3x2fNV) New() binary.Object { return &GlMatrixLoad3x2fNV{} }
func (*binaryClassGlMatrixLoad3x2fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixLoad3x2fNV(e, obj.(*GlMatrixLoad3x2fNV))
}
func (*binaryClassGlMatrixLoad3x2fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixLoad3x2fNV{}
	return obj, doDecodeGlMatrixLoad3x2fNV(d, obj)
}
func (*binaryClassGlMatrixLoad3x2fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixLoad3x2fNV(d, obj.(*GlMatrixLoad3x2fNV))
}
func (*binaryClassGlMatrixLoad3x2fNV) Skip(d binary.Decoder) error { return doSkipGlMatrixLoad3x2fNV(d) }
func (*binaryClassGlMatrixLoad3x2fNV) Schema() *schema.Class       { return schemaGlMatrixLoad3x2fNV }

var schemaGlMatrixLoad3x2fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixLoad3x2fNV,
	Package: "gles",
	Name:    "GlMatrixLoad3x2fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixLoad3x3fNV struct{}

func (*GlMatrixLoad3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoad3x3fNV)(nil)
}
func doEncodeGlMatrixLoad3x3fNV(e binary.Encoder, o *GlMatrixLoad3x3fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixLoad3x3fNV(d binary.Decoder, o *GlMatrixLoad3x3fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixLoad3x3fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixLoad3x3fNV) ID() binary.ID      { return binaryIDGlMatrixLoad3x3fNV }
func (*binaryClassGlMatrixLoad3x3fNV) New() binary.Object { return &GlMatrixLoad3x3fNV{} }
func (*binaryClassGlMatrixLoad3x3fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixLoad3x3fNV(e, obj.(*GlMatrixLoad3x3fNV))
}
func (*binaryClassGlMatrixLoad3x3fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixLoad3x3fNV{}
	return obj, doDecodeGlMatrixLoad3x3fNV(d, obj)
}
func (*binaryClassGlMatrixLoad3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixLoad3x3fNV(d, obj.(*GlMatrixLoad3x3fNV))
}
func (*binaryClassGlMatrixLoad3x3fNV) Skip(d binary.Decoder) error { return doSkipGlMatrixLoad3x3fNV(d) }
func (*binaryClassGlMatrixLoad3x3fNV) Schema() *schema.Class       { return schemaGlMatrixLoad3x3fNV }

var schemaGlMatrixLoad3x3fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixLoad3x3fNV,
	Package: "gles",
	Name:    "GlMatrixLoad3x3fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixLoadTranspose3x3fNV struct{}

func (*GlMatrixLoadTranspose3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixLoadTranspose3x3fNV)(nil)
}
func doEncodeGlMatrixLoadTranspose3x3fNV(e binary.Encoder, o *GlMatrixLoadTranspose3x3fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixLoadTranspose3x3fNV(d binary.Decoder, o *GlMatrixLoadTranspose3x3fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixLoadTranspose3x3fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) ID() binary.ID {
	return binaryIDGlMatrixLoadTranspose3x3fNV
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) New() binary.Object {
	return &GlMatrixLoadTranspose3x3fNV{}
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixLoadTranspose3x3fNV(e, obj.(*GlMatrixLoadTranspose3x3fNV))
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixLoadTranspose3x3fNV{}
	return obj, doDecodeGlMatrixLoadTranspose3x3fNV(d, obj)
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixLoadTranspose3x3fNV(d, obj.(*GlMatrixLoadTranspose3x3fNV))
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) Skip(d binary.Decoder) error {
	return doSkipGlMatrixLoadTranspose3x3fNV(d)
}
func (*binaryClassGlMatrixLoadTranspose3x3fNV) Schema() *schema.Class {
	return schemaGlMatrixLoadTranspose3x3fNV
}

var schemaGlMatrixLoadTranspose3x3fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixLoadTranspose3x3fNV,
	Package: "gles",
	Name:    "GlMatrixLoadTranspose3x3fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixMult3x2fNV struct{}

func (*GlMatrixMult3x2fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMult3x2fNV)(nil)
}
func doEncodeGlMatrixMult3x2fNV(e binary.Encoder, o *GlMatrixMult3x2fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixMult3x2fNV(d binary.Decoder, o *GlMatrixMult3x2fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixMult3x2fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixMult3x2fNV) ID() binary.ID      { return binaryIDGlMatrixMult3x2fNV }
func (*binaryClassGlMatrixMult3x2fNV) New() binary.Object { return &GlMatrixMult3x2fNV{} }
func (*binaryClassGlMatrixMult3x2fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixMult3x2fNV(e, obj.(*GlMatrixMult3x2fNV))
}
func (*binaryClassGlMatrixMult3x2fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixMult3x2fNV{}
	return obj, doDecodeGlMatrixMult3x2fNV(d, obj)
}
func (*binaryClassGlMatrixMult3x2fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixMult3x2fNV(d, obj.(*GlMatrixMult3x2fNV))
}
func (*binaryClassGlMatrixMult3x2fNV) Skip(d binary.Decoder) error { return doSkipGlMatrixMult3x2fNV(d) }
func (*binaryClassGlMatrixMult3x2fNV) Schema() *schema.Class       { return schemaGlMatrixMult3x2fNV }

var schemaGlMatrixMult3x2fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixMult3x2fNV,
	Package: "gles",
	Name:    "GlMatrixMult3x2fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixMult3x3fNV struct{}

func (*GlMatrixMult3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMult3x3fNV)(nil)
}
func doEncodeGlMatrixMult3x3fNV(e binary.Encoder, o *GlMatrixMult3x3fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixMult3x3fNV(d binary.Decoder, o *GlMatrixMult3x3fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixMult3x3fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixMult3x3fNV) ID() binary.ID      { return binaryIDGlMatrixMult3x3fNV }
func (*binaryClassGlMatrixMult3x3fNV) New() binary.Object { return &GlMatrixMult3x3fNV{} }
func (*binaryClassGlMatrixMult3x3fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixMult3x3fNV(e, obj.(*GlMatrixMult3x3fNV))
}
func (*binaryClassGlMatrixMult3x3fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixMult3x3fNV{}
	return obj, doDecodeGlMatrixMult3x3fNV(d, obj)
}
func (*binaryClassGlMatrixMult3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixMult3x3fNV(d, obj.(*GlMatrixMult3x3fNV))
}
func (*binaryClassGlMatrixMult3x3fNV) Skip(d binary.Decoder) error { return doSkipGlMatrixMult3x3fNV(d) }
func (*binaryClassGlMatrixMult3x3fNV) Schema() *schema.Class       { return schemaGlMatrixMult3x3fNV }

var schemaGlMatrixMult3x3fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixMult3x3fNV,
	Package: "gles",
	Name:    "GlMatrixMult3x3fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMatrixMultTranspose3x3fNV struct{}

func (*GlMatrixMultTranspose3x3fNV) Class() binary.Class {
	return (*binaryClassGlMatrixMultTranspose3x3fNV)(nil)
}
func doEncodeGlMatrixMultTranspose3x3fNV(e binary.Encoder, o *GlMatrixMultTranspose3x3fNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MatrixMode)); err != nil {
		return err
	}
	if err := e.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMatrixMultTranspose3x3fNV(d binary.Decoder, o *GlMatrixMultTranspose3x3fNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MatrixMode = GLenum(obj)
	}
	if err := d.Value(&o.M); err != nil {
		return err
	}
	return nil
}
func doSkipGlMatrixMultTranspose3x3fNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) ID() binary.ID {
	return binaryIDGlMatrixMultTranspose3x3fNV
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) New() binary.Object {
	return &GlMatrixMultTranspose3x3fNV{}
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMatrixMultTranspose3x3fNV(e, obj.(*GlMatrixMultTranspose3x3fNV))
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMatrixMultTranspose3x3fNV{}
	return obj, doDecodeGlMatrixMultTranspose3x3fNV(d, obj)
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMatrixMultTranspose3x3fNV(d, obj.(*GlMatrixMultTranspose3x3fNV))
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) Skip(d binary.Decoder) error {
	return doSkipGlMatrixMultTranspose3x3fNV(d)
}
func (*binaryClassGlMatrixMultTranspose3x3fNV) Schema() *schema.Class {
	return schemaGlMatrixMultTranspose3x3fNV
}

var schemaGlMatrixMultTranspose3x3fNV = &schema.Class{
	TypeID:  binaryIDGlMatrixMultTranspose3x3fNV,
	Package: "gles",
	Name:    "GlMatrixMultTranspose3x3fNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MatrixMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "M", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMemoryBarrier struct{}

func (*GlMemoryBarrier) Class() binary.Class {
	return (*binaryClassGlMemoryBarrier)(nil)
}
func doEncodeGlMemoryBarrier(e binary.Encoder, o *GlMemoryBarrier) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Barriers)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMemoryBarrier(d binary.Decoder, o *GlMemoryBarrier) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Barriers = GLbitfield(obj)
	}
	return nil
}
func doSkipGlMemoryBarrier(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMemoryBarrier) ID() binary.ID      { return binaryIDGlMemoryBarrier }
func (*binaryClassGlMemoryBarrier) New() binary.Object { return &GlMemoryBarrier{} }
func (*binaryClassGlMemoryBarrier) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMemoryBarrier(e, obj.(*GlMemoryBarrier))
}
func (*binaryClassGlMemoryBarrier) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMemoryBarrier{}
	return obj, doDecodeGlMemoryBarrier(d, obj)
}
func (*binaryClassGlMemoryBarrier) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMemoryBarrier(d, obj.(*GlMemoryBarrier))
}
func (*binaryClassGlMemoryBarrier) Skip(d binary.Decoder) error { return doSkipGlMemoryBarrier(d) }
func (*binaryClassGlMemoryBarrier) Schema() *schema.Class       { return schemaGlMemoryBarrier }

var schemaGlMemoryBarrier = &schema.Class{
	TypeID:  binaryIDGlMemoryBarrier,
	Package: "gles",
	Name:    "GlMemoryBarrier",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Barriers", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlMemoryBarrierByRegion struct{}

func (*GlMemoryBarrierByRegion) Class() binary.Class {
	return (*binaryClassGlMemoryBarrierByRegion)(nil)
}
func doEncodeGlMemoryBarrierByRegion(e binary.Encoder, o *GlMemoryBarrierByRegion) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Barriers)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMemoryBarrierByRegion(d binary.Decoder, o *GlMemoryBarrierByRegion) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Barriers = GLbitfield(obj)
	}
	return nil
}
func doSkipGlMemoryBarrierByRegion(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMemoryBarrierByRegion) ID() binary.ID      { return binaryIDGlMemoryBarrierByRegion }
func (*binaryClassGlMemoryBarrierByRegion) New() binary.Object { return &GlMemoryBarrierByRegion{} }
func (*binaryClassGlMemoryBarrierByRegion) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMemoryBarrierByRegion(e, obj.(*GlMemoryBarrierByRegion))
}
func (*binaryClassGlMemoryBarrierByRegion) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMemoryBarrierByRegion{}
	return obj, doDecodeGlMemoryBarrierByRegion(d, obj)
}
func (*binaryClassGlMemoryBarrierByRegion) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMemoryBarrierByRegion(d, obj.(*GlMemoryBarrierByRegion))
}
func (*binaryClassGlMemoryBarrierByRegion) Skip(d binary.Decoder) error {
	return doSkipGlMemoryBarrierByRegion(d)
}
func (*binaryClassGlMemoryBarrierByRegion) Schema() *schema.Class {
	return schemaGlMemoryBarrierByRegion
}

var schemaGlMemoryBarrierByRegion = &schema.Class{
	TypeID:  binaryIDGlMemoryBarrierByRegion,
	Package: "gles",
	Name:    "GlMemoryBarrierByRegion",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Barriers", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlMinSampleShadingOES struct{}

func (*GlMinSampleShadingOES) Class() binary.Class {
	return (*binaryClassGlMinSampleShadingOES)(nil)
}
func doEncodeGlMinSampleShadingOES(e binary.Encoder, o *GlMinSampleShadingOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMinSampleShadingOES(d binary.Decoder, o *GlMinSampleShadingOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value = GLfloat(obj)
	}
	return nil
}
func doSkipGlMinSampleShadingOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMinSampleShadingOES) ID() binary.ID      { return binaryIDGlMinSampleShadingOES }
func (*binaryClassGlMinSampleShadingOES) New() binary.Object { return &GlMinSampleShadingOES{} }
func (*binaryClassGlMinSampleShadingOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMinSampleShadingOES(e, obj.(*GlMinSampleShadingOES))
}
func (*binaryClassGlMinSampleShadingOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMinSampleShadingOES{}
	return obj, doDecodeGlMinSampleShadingOES(d, obj)
}
func (*binaryClassGlMinSampleShadingOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMinSampleShadingOES(d, obj.(*GlMinSampleShadingOES))
}
func (*binaryClassGlMinSampleShadingOES) Skip(d binary.Decoder) error {
	return doSkipGlMinSampleShadingOES(d)
}
func (*binaryClassGlMinSampleShadingOES) Schema() *schema.Class { return schemaGlMinSampleShadingOES }

var schemaGlMinSampleShadingOES = &schema.Class{
	TypeID:  binaryIDGlMinSampleShadingOES,
	Package: "gles",
	Name:    "GlMinSampleShadingOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlMultiDrawArraysEXT struct{}

func (*GlMultiDrawArraysEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawArraysEXT)(nil)
}
func doEncodeGlMultiDrawArraysEXT(e binary.Encoder, o *GlMultiDrawArraysEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.First); err != nil {
		return err
	}
	if err := e.Value(&o.Count); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawArraysEXT(d binary.Decoder, o *GlMultiDrawArraysEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.First); err != nil {
		return err
	}
	if err := d.Value(&o.Count); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlMultiDrawArraysEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawArraysEXT) ID() binary.ID      { return binaryIDGlMultiDrawArraysEXT }
func (*binaryClassGlMultiDrawArraysEXT) New() binary.Object { return &GlMultiDrawArraysEXT{} }
func (*binaryClassGlMultiDrawArraysEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawArraysEXT(e, obj.(*GlMultiDrawArraysEXT))
}
func (*binaryClassGlMultiDrawArraysEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawArraysEXT{}
	return obj, doDecodeGlMultiDrawArraysEXT(d, obj)
}
func (*binaryClassGlMultiDrawArraysEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawArraysEXT(d, obj.(*GlMultiDrawArraysEXT))
}
func (*binaryClassGlMultiDrawArraysEXT) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawArraysEXT(d)
}
func (*binaryClassGlMultiDrawArraysEXT) Schema() *schema.Class { return schemaGlMultiDrawArraysEXT }

var schemaGlMultiDrawArraysEXT = &schema.Class{
	TypeID:  binaryIDGlMultiDrawArraysEXT,
	Package: "gles",
	Name:    "GlMultiDrawArraysEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "First", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Struct{Name: "GLsizeiᶜᵖ", ID: (*GLsizeiᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlMultiDrawArraysIndirectEXT struct{}

func (*GlMultiDrawArraysIndirectEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawArraysIndirectEXT)(nil)
}
func doEncodeGlMultiDrawArraysIndirectEXT(e binary.Encoder, o *GlMultiDrawArraysIndirectEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.Indirect); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawcount)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawArraysIndirectEXT(d binary.Decoder, o *GlMultiDrawArraysIndirectEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.Indirect); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawcount = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	return nil
}
func doSkipGlMultiDrawArraysIndirectEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) ID() binary.ID {
	return binaryIDGlMultiDrawArraysIndirectEXT
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) New() binary.Object {
	return &GlMultiDrawArraysIndirectEXT{}
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawArraysIndirectEXT(e, obj.(*GlMultiDrawArraysIndirectEXT))
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawArraysIndirectEXT{}
	return obj, doDecodeGlMultiDrawArraysIndirectEXT(d, obj)
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawArraysIndirectEXT(d, obj.(*GlMultiDrawArraysIndirectEXT))
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawArraysIndirectEXT(d)
}
func (*binaryClassGlMultiDrawArraysIndirectEXT) Schema() *schema.Class {
	return schemaGlMultiDrawArraysIndirectEXT
}

var schemaGlMultiDrawArraysIndirectEXT = &schema.Class{
	TypeID:  binaryIDGlMultiDrawArraysIndirectEXT,
	Package: "gles",
	Name:    "GlMultiDrawArraysIndirectEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indirect", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Drawcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassVoidᶜᵖᶜᵖ struct{}

func (*Voidᶜᵖᶜᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖᶜᵖ)(nil)
}
func doEncodeVoidᶜᵖᶜᵖ(e binary.Encoder, o *Voidᶜᵖᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᶜᵖᶜᵖ(d binary.Decoder, o *Voidᶜᵖᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᶜᵖᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᶜᵖᶜᵖ) ID() binary.ID      { return binaryIDVoidᶜᵖᶜᵖ }
func (*binaryClassVoidᶜᵖᶜᵖ) New() binary.Object { return &Voidᶜᵖᶜᵖ{} }
func (*binaryClassVoidᶜᵖᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᶜᵖᶜᵖ(e, obj.(*Voidᶜᵖᶜᵖ))
}
func (*binaryClassVoidᶜᵖᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᶜᵖᶜᵖ{}
	return obj, doDecodeVoidᶜᵖᶜᵖ(d, obj)
}
func (*binaryClassVoidᶜᵖᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᶜᵖᶜᵖ(d, obj.(*Voidᶜᵖᶜᵖ))
}
func (*binaryClassVoidᶜᵖᶜᵖ) Skip(d binary.Decoder) error { return doSkipVoidᶜᵖᶜᵖ(d) }
func (*binaryClassVoidᶜᵖᶜᵖ) Schema() *schema.Class       { return schemaVoidᶜᵖᶜᵖ }

var schemaVoidᶜᵖᶜᵖ = &schema.Class{
	TypeID:  binaryIDVoidᶜᵖᶜᵖ,
	Package: "gles",
	Name:    "Voidᶜᵖᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlMultiDrawElementsBaseVertexEXT struct{}

func (*GlMultiDrawElementsBaseVertexEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsBaseVertexEXT)(nil)
}
func doEncodeGlMultiDrawElementsBaseVertexEXT(e binary.Encoder, o *GlMultiDrawElementsBaseVertexEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.Count); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	if err := e.Value(&o.Basevertex); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawElementsBaseVertexEXT(d binary.Decoder, o *GlMultiDrawElementsBaseVertexEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.Count); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	if err := d.Value(&o.Basevertex); err != nil {
		return err
	}
	return nil
}
func doSkipGlMultiDrawElementsBaseVertexEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) ID() binary.ID {
	return binaryIDGlMultiDrawElementsBaseVertexEXT
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) New() binary.Object {
	return &GlMultiDrawElementsBaseVertexEXT{}
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawElementsBaseVertexEXT(e, obj.(*GlMultiDrawElementsBaseVertexEXT))
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawElementsBaseVertexEXT{}
	return obj, doDecodeGlMultiDrawElementsBaseVertexEXT(d, obj)
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawElementsBaseVertexEXT(d, obj.(*GlMultiDrawElementsBaseVertexEXT))
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawElementsBaseVertexEXT(d)
}
func (*binaryClassGlMultiDrawElementsBaseVertexEXT) Schema() *schema.Class {
	return schemaGlMultiDrawElementsBaseVertexEXT
}

var schemaGlMultiDrawElementsBaseVertexEXT = &schema.Class{
	TypeID:  binaryIDGlMultiDrawElementsBaseVertexEXT,
	Package: "gles",
	Name:    "GlMultiDrawElementsBaseVertexEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Struct{Name: "GLsizeiᶜᵖ", ID: (*GLsizeiᶜᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖᶜᵖ", ID: (*Voidᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Basevertex", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMultiDrawElementsBaseVertexOES struct{}

func (*GlMultiDrawElementsBaseVertexOES) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsBaseVertexOES)(nil)
}
func doEncodeGlMultiDrawElementsBaseVertexOES(e binary.Encoder, o *GlMultiDrawElementsBaseVertexOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.Count); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	if err := e.Value(&o.Basevertex); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawElementsBaseVertexOES(d binary.Decoder, o *GlMultiDrawElementsBaseVertexOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.Count); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	if err := d.Value(&o.Basevertex); err != nil {
		return err
	}
	return nil
}
func doSkipGlMultiDrawElementsBaseVertexOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) ID() binary.ID {
	return binaryIDGlMultiDrawElementsBaseVertexOES
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) New() binary.Object {
	return &GlMultiDrawElementsBaseVertexOES{}
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawElementsBaseVertexOES(e, obj.(*GlMultiDrawElementsBaseVertexOES))
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawElementsBaseVertexOES{}
	return obj, doDecodeGlMultiDrawElementsBaseVertexOES(d, obj)
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawElementsBaseVertexOES(d, obj.(*GlMultiDrawElementsBaseVertexOES))
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawElementsBaseVertexOES(d)
}
func (*binaryClassGlMultiDrawElementsBaseVertexOES) Schema() *schema.Class {
	return schemaGlMultiDrawElementsBaseVertexOES
}

var schemaGlMultiDrawElementsBaseVertexOES = &schema.Class{
	TypeID:  binaryIDGlMultiDrawElementsBaseVertexOES,
	Package: "gles",
	Name:    "GlMultiDrawElementsBaseVertexOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Struct{Name: "GLsizeiᶜᵖ", ID: (*GLsizeiᶜᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖᶜᵖ", ID: (*Voidᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Basevertex", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlMultiDrawElementsEXT struct{}

func (*GlMultiDrawElementsEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsEXT)(nil)
}
func doEncodeGlMultiDrawElementsEXT(e binary.Encoder, o *GlMultiDrawElementsEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Value(&o.Count); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indices); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Primcount)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawElementsEXT(d binary.Decoder, o *GlMultiDrawElementsEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if err := d.Value(&o.Count); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indices); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Primcount = GLsizei(obj)
	}
	return nil
}
func doSkipGlMultiDrawElementsEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLsizeiᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawElementsEXT) ID() binary.ID      { return binaryIDGlMultiDrawElementsEXT }
func (*binaryClassGlMultiDrawElementsEXT) New() binary.Object { return &GlMultiDrawElementsEXT{} }
func (*binaryClassGlMultiDrawElementsEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawElementsEXT(e, obj.(*GlMultiDrawElementsEXT))
}
func (*binaryClassGlMultiDrawElementsEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawElementsEXT{}
	return obj, doDecodeGlMultiDrawElementsEXT(d, obj)
}
func (*binaryClassGlMultiDrawElementsEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawElementsEXT(d, obj.(*GlMultiDrawElementsEXT))
}
func (*binaryClassGlMultiDrawElementsEXT) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawElementsEXT(d)
}
func (*binaryClassGlMultiDrawElementsEXT) Schema() *schema.Class { return schemaGlMultiDrawElementsEXT }

var schemaGlMultiDrawElementsEXT = &schema.Class{
	TypeID:  binaryIDGlMultiDrawElementsEXT,
	Package: "gles",
	Name:    "GlMultiDrawElementsEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Struct{Name: "GLsizeiᶜᵖ", ID: (*GLsizeiᶜᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indices", Type: &schema.Struct{Name: "Voidᶜᵖᶜᵖ", ID: (*Voidᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "Primcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlMultiDrawElementsIndirectEXT struct{}

func (*GlMultiDrawElementsIndirectEXT) Class() binary.Class {
	return (*binaryClassGlMultiDrawElementsIndirectEXT)(nil)
}
func doEncodeGlMultiDrawElementsIndirectEXT(e binary.Encoder, o *GlMultiDrawElementsIndirectEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Indirect); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Drawcount)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlMultiDrawElementsIndirectEXT(d binary.Decoder, o *GlMultiDrawElementsIndirectEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Indirect); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Drawcount = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	return nil
}
func doSkipGlMultiDrawElementsIndirectEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) ID() binary.ID {
	return binaryIDGlMultiDrawElementsIndirectEXT
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) New() binary.Object {
	return &GlMultiDrawElementsIndirectEXT{}
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlMultiDrawElementsIndirectEXT(e, obj.(*GlMultiDrawElementsIndirectEXT))
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlMultiDrawElementsIndirectEXT{}
	return obj, doDecodeGlMultiDrawElementsIndirectEXT(d, obj)
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlMultiDrawElementsIndirectEXT(d, obj.(*GlMultiDrawElementsIndirectEXT))
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) Skip(d binary.Decoder) error {
	return doSkipGlMultiDrawElementsIndirectEXT(d)
}
func (*binaryClassGlMultiDrawElementsIndirectEXT) Schema() *schema.Class {
	return schemaGlMultiDrawElementsIndirectEXT
}

var schemaGlMultiDrawElementsIndirectEXT = &schema.Class{
	TypeID:  binaryIDGlMultiDrawElementsIndirectEXT,
	Package: "gles",
	Name:    "GlMultiDrawElementsIndirectEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Indirect", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Drawcount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlNamedFramebufferSampleLocationsfvNV struct{}

func (*GlNamedFramebufferSampleLocationsfvNV) Class() binary.Class {
	return (*binaryClassGlNamedFramebufferSampleLocationsfvNV)(nil)
}
func doEncodeGlNamedFramebufferSampleLocationsfvNV(e binary.Encoder, o *GlNamedFramebufferSampleLocationsfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Framebuffer)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Start)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlNamedFramebufferSampleLocationsfvNV(d binary.Decoder, o *GlNamedFramebufferSampleLocationsfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Framebuffer = FramebufferId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Start = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlNamedFramebufferSampleLocationsfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) ID() binary.ID {
	return binaryIDGlNamedFramebufferSampleLocationsfvNV
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) New() binary.Object {
	return &GlNamedFramebufferSampleLocationsfvNV{}
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlNamedFramebufferSampleLocationsfvNV(e, obj.(*GlNamedFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlNamedFramebufferSampleLocationsfvNV{}
	return obj, doDecodeGlNamedFramebufferSampleLocationsfvNV(d, obj)
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlNamedFramebufferSampleLocationsfvNV(d, obj.(*GlNamedFramebufferSampleLocationsfvNV))
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) Skip(d binary.Decoder) error {
	return doSkipGlNamedFramebufferSampleLocationsfvNV(d)
}
func (*binaryClassGlNamedFramebufferSampleLocationsfvNV) Schema() *schema.Class {
	return schemaGlNamedFramebufferSampleLocationsfvNV
}

var schemaGlNamedFramebufferSampleLocationsfvNV = &schema.Class{
	TypeID:  binaryIDGlNamedFramebufferSampleLocationsfvNV,
	Package: "gles",
	Name:    "GlNamedFramebufferSampleLocationsfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}},
		{Declared: "Start", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlObjectLabelKHR struct{}

func (*GlObjectLabelKHR) Class() binary.Class {
	return (*binaryClassGlObjectLabelKHR)(nil)
}
func doEncodeGlObjectLabelKHR(e binary.Encoder, o *GlObjectLabelKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Identifier)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Name)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlObjectLabelKHR(d binary.Decoder, o *GlObjectLabelKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Identifier = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Name = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlObjectLabelKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlObjectLabelKHR) ID() binary.ID      { return binaryIDGlObjectLabelKHR }
func (*binaryClassGlObjectLabelKHR) New() binary.Object { return &GlObjectLabelKHR{} }
func (*binaryClassGlObjectLabelKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlObjectLabelKHR(e, obj.(*GlObjectLabelKHR))
}
func (*binaryClassGlObjectLabelKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlObjectLabelKHR{}
	return obj, doDecodeGlObjectLabelKHR(d, obj)
}
func (*binaryClassGlObjectLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlObjectLabelKHR(d, obj.(*GlObjectLabelKHR))
}
func (*binaryClassGlObjectLabelKHR) Skip(d binary.Decoder) error { return doSkipGlObjectLabelKHR(d) }
func (*binaryClassGlObjectLabelKHR) Schema() *schema.Class       { return schemaGlObjectLabelKHR }

var schemaGlObjectLabelKHR = &schema.Class{
	TypeID:  binaryIDGlObjectLabelKHR,
	Package: "gles",
	Name:    "GlObjectLabelKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Identifier", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Name", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlObjectPtrLabelKHR struct{}

func (*GlObjectPtrLabelKHR) Class() binary.Class {
	return (*binaryClassGlObjectPtrLabelKHR)(nil)
}
func doEncodeGlObjectPtrLabelKHR(e binary.Encoder, o *GlObjectPtrLabelKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Ptr); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doDecodeGlObjectPtrLabelKHR(d binary.Decoder, o *GlObjectPtrLabelKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Ptr); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Label); err != nil {
		return err
	}
	return nil
}
func doSkipGlObjectPtrLabelKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlObjectPtrLabelKHR) ID() binary.ID      { return binaryIDGlObjectPtrLabelKHR }
func (*binaryClassGlObjectPtrLabelKHR) New() binary.Object { return &GlObjectPtrLabelKHR{} }
func (*binaryClassGlObjectPtrLabelKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlObjectPtrLabelKHR(e, obj.(*GlObjectPtrLabelKHR))
}
func (*binaryClassGlObjectPtrLabelKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlObjectPtrLabelKHR{}
	return obj, doDecodeGlObjectPtrLabelKHR(d, obj)
}
func (*binaryClassGlObjectPtrLabelKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlObjectPtrLabelKHR(d, obj.(*GlObjectPtrLabelKHR))
}
func (*binaryClassGlObjectPtrLabelKHR) Skip(d binary.Decoder) error {
	return doSkipGlObjectPtrLabelKHR(d)
}
func (*binaryClassGlObjectPtrLabelKHR) Schema() *schema.Class { return schemaGlObjectPtrLabelKHR }

var schemaGlObjectPtrLabelKHR = &schema.Class{
	TypeID:  binaryIDGlObjectPtrLabelKHR,
	Package: "gles",
	Name:    "GlObjectPtrLabelKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Ptr", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Label", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPatchParameteriEXT struct{}

func (*GlPatchParameteriEXT) Class() binary.Class {
	return (*binaryClassGlPatchParameteriEXT)(nil)
}
func doEncodeGlPatchParameteriEXT(e binary.Encoder, o *GlPatchParameteriEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPatchParameteriEXT(d binary.Decoder, o *GlPatchParameteriEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlPatchParameteriEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPatchParameteriEXT) ID() binary.ID      { return binaryIDGlPatchParameteriEXT }
func (*binaryClassGlPatchParameteriEXT) New() binary.Object { return &GlPatchParameteriEXT{} }
func (*binaryClassGlPatchParameteriEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPatchParameteriEXT(e, obj.(*GlPatchParameteriEXT))
}
func (*binaryClassGlPatchParameteriEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPatchParameteriEXT{}
	return obj, doDecodeGlPatchParameteriEXT(d, obj)
}
func (*binaryClassGlPatchParameteriEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPatchParameteriEXT(d, obj.(*GlPatchParameteriEXT))
}
func (*binaryClassGlPatchParameteriEXT) Skip(d binary.Decoder) error {
	return doSkipGlPatchParameteriEXT(d)
}
func (*binaryClassGlPatchParameteriEXT) Schema() *schema.Class { return schemaGlPatchParameteriEXT }

var schemaGlPatchParameteriEXT = &schema.Class{
	TypeID:  binaryIDGlPatchParameteriEXT,
	Package: "gles",
	Name:    "GlPatchParameteriEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlPatchParameteriOES struct{}

func (*GlPatchParameteriOES) Class() binary.Class {
	return (*binaryClassGlPatchParameteriOES)(nil)
}
func doEncodeGlPatchParameteriOES(e binary.Encoder, o *GlPatchParameteriOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPatchParameteriOES(d binary.Decoder, o *GlPatchParameteriOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlPatchParameteriOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPatchParameteriOES) ID() binary.ID      { return binaryIDGlPatchParameteriOES }
func (*binaryClassGlPatchParameteriOES) New() binary.Object { return &GlPatchParameteriOES{} }
func (*binaryClassGlPatchParameteriOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPatchParameteriOES(e, obj.(*GlPatchParameteriOES))
}
func (*binaryClassGlPatchParameteriOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPatchParameteriOES{}
	return obj, doDecodeGlPatchParameteriOES(d, obj)
}
func (*binaryClassGlPatchParameteriOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPatchParameteriOES(d, obj.(*GlPatchParameteriOES))
}
func (*binaryClassGlPatchParameteriOES) Skip(d binary.Decoder) error {
	return doSkipGlPatchParameteriOES(d)
}
func (*binaryClassGlPatchParameteriOES) Schema() *schema.Class { return schemaGlPatchParameteriOES }

var schemaGlPatchParameteriOES = &schema.Class{
	TypeID:  binaryIDGlPatchParameteriOES,
	Package: "gles",
	Name:    "GlPatchParameteriOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlPathCommandsNV struct{}

func (*GlPathCommandsNV) Class() binary.Class {
	return (*binaryClassGlPathCommandsNV)(nil)
}
func doEncodeGlPathCommandsNV(e binary.Encoder, o *GlPathCommandsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCommands)); err != nil {
		return err
	}
	if err := e.Value(&o.Commands); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCoords)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoordType)); err != nil {
		return err
	}
	if err := e.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathCommandsNV(d binary.Decoder, o *GlPathCommandsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCommands = GLsizei(obj)
	}
	if err := d.Value(&o.Commands); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCoords = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoordType = GLenum(obj)
	}
	if err := d.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathCommandsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLubyteᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathCommandsNV) ID() binary.ID      { return binaryIDGlPathCommandsNV }
func (*binaryClassGlPathCommandsNV) New() binary.Object { return &GlPathCommandsNV{} }
func (*binaryClassGlPathCommandsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathCommandsNV(e, obj.(*GlPathCommandsNV))
}
func (*binaryClassGlPathCommandsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathCommandsNV{}
	return obj, doDecodeGlPathCommandsNV(d, obj)
}
func (*binaryClassGlPathCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathCommandsNV(d, obj.(*GlPathCommandsNV))
}
func (*binaryClassGlPathCommandsNV) Skip(d binary.Decoder) error { return doSkipGlPathCommandsNV(d) }
func (*binaryClassGlPathCommandsNV) Schema() *schema.Class       { return schemaGlPathCommandsNV }

var schemaGlPathCommandsNV = &schema.Class{
	TypeID:  binaryIDGlPathCommandsNV,
	Package: "gles",
	Name:    "GlPathCommandsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumCommands", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Commands", Type: &schema.Struct{Name: "GLubyteᶜᵖ", ID: (*GLubyteᶜᵖ)(nil).Class().ID()}},
		{Declared: "NumCoords", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "CoordType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Coords", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathCoordsNV struct{}

func (*GlPathCoordsNV) Class() binary.Class {
	return (*binaryClassGlPathCoordsNV)(nil)
}
func doEncodeGlPathCoordsNV(e binary.Encoder, o *GlPathCoordsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCoords)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoordType)); err != nil {
		return err
	}
	if err := e.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathCoordsNV(d binary.Decoder, o *GlPathCoordsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCoords = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoordType = GLenum(obj)
	}
	if err := d.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathCoordsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathCoordsNV) ID() binary.ID      { return binaryIDGlPathCoordsNV }
func (*binaryClassGlPathCoordsNV) New() binary.Object { return &GlPathCoordsNV{} }
func (*binaryClassGlPathCoordsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathCoordsNV(e, obj.(*GlPathCoordsNV))
}
func (*binaryClassGlPathCoordsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathCoordsNV{}
	return obj, doDecodeGlPathCoordsNV(d, obj)
}
func (*binaryClassGlPathCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathCoordsNV(d, obj.(*GlPathCoordsNV))
}
func (*binaryClassGlPathCoordsNV) Skip(d binary.Decoder) error { return doSkipGlPathCoordsNV(d) }
func (*binaryClassGlPathCoordsNV) Schema() *schema.Class       { return schemaGlPathCoordsNV }

var schemaGlPathCoordsNV = &schema.Class{
	TypeID:  binaryIDGlPathCoordsNV,
	Package: "gles",
	Name:    "GlPathCoordsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumCoords", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "CoordType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Coords", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathCoverDepthFuncNV struct{}

func (*GlPathCoverDepthFuncNV) Class() binary.Class {
	return (*binaryClassGlPathCoverDepthFuncNV)(nil)
}
func doEncodeGlPathCoverDepthFuncNV(e binary.Encoder, o *GlPathCoverDepthFuncNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Func)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathCoverDepthFuncNV(d binary.Decoder, o *GlPathCoverDepthFuncNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Func = GLenum(obj)
	}
	return nil
}
func doSkipGlPathCoverDepthFuncNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathCoverDepthFuncNV) ID() binary.ID      { return binaryIDGlPathCoverDepthFuncNV }
func (*binaryClassGlPathCoverDepthFuncNV) New() binary.Object { return &GlPathCoverDepthFuncNV{} }
func (*binaryClassGlPathCoverDepthFuncNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathCoverDepthFuncNV(e, obj.(*GlPathCoverDepthFuncNV))
}
func (*binaryClassGlPathCoverDepthFuncNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathCoverDepthFuncNV{}
	return obj, doDecodeGlPathCoverDepthFuncNV(d, obj)
}
func (*binaryClassGlPathCoverDepthFuncNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathCoverDepthFuncNV(d, obj.(*GlPathCoverDepthFuncNV))
}
func (*binaryClassGlPathCoverDepthFuncNV) Skip(d binary.Decoder) error {
	return doSkipGlPathCoverDepthFuncNV(d)
}
func (*binaryClassGlPathCoverDepthFuncNV) Schema() *schema.Class { return schemaGlPathCoverDepthFuncNV }

var schemaGlPathCoverDepthFuncNV = &schema.Class{
	TypeID:  binaryIDGlPathCoverDepthFuncNV,
	Package: "gles",
	Name:    "GlPathCoverDepthFuncNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Func", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlPathDashArrayNV struct{}

func (*GlPathDashArrayNV) Class() binary.Class {
	return (*binaryClassGlPathDashArrayNV)(nil)
}
func doEncodeGlPathDashArrayNV(e binary.Encoder, o *GlPathDashArrayNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.DashCount)); err != nil {
		return err
	}
	if err := e.Value(&o.DashArray); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathDashArrayNV(d binary.Decoder, o *GlPathDashArrayNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.DashCount = GLsizei(obj)
	}
	if err := d.Value(&o.DashArray); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathDashArrayNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathDashArrayNV) ID() binary.ID      { return binaryIDGlPathDashArrayNV }
func (*binaryClassGlPathDashArrayNV) New() binary.Object { return &GlPathDashArrayNV{} }
func (*binaryClassGlPathDashArrayNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathDashArrayNV(e, obj.(*GlPathDashArrayNV))
}
func (*binaryClassGlPathDashArrayNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathDashArrayNV{}
	return obj, doDecodeGlPathDashArrayNV(d, obj)
}
func (*binaryClassGlPathDashArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathDashArrayNV(d, obj.(*GlPathDashArrayNV))
}
func (*binaryClassGlPathDashArrayNV) Skip(d binary.Decoder) error { return doSkipGlPathDashArrayNV(d) }
func (*binaryClassGlPathDashArrayNV) Schema() *schema.Class       { return schemaGlPathDashArrayNV }

var schemaGlPathDashArrayNV = &schema.Class{
	TypeID:  binaryIDGlPathDashArrayNV,
	Package: "gles",
	Name:    "GlPathDashArrayNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "DashCount", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "DashArray", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathGlyphIndexArrayNV struct{}

func (*GlPathGlyphIndexArrayNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphIndexArrayNV)(nil)
}
func doEncodeGlPathGlyphIndexArrayNV(e binary.Encoder, o *GlPathGlyphIndexArrayNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstPathName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontTarget)); err != nil {
		return err
	}
	if err := e.Value(&o.FontName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontStyle)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstGlyphIndex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathParameterTemplate)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.EmScale)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathGlyphIndexArrayNV(d binary.Decoder, o *GlPathGlyphIndexArrayNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstPathName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontTarget = GLenum(obj)
	}
	if err := d.Value(&o.FontName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontStyle = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstGlyphIndex = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumGlyphs = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathParameterTemplate = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.EmScale = GLfloat(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlPathGlyphIndexArrayNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathGlyphIndexArrayNV) ID() binary.ID      { return binaryIDGlPathGlyphIndexArrayNV }
func (*binaryClassGlPathGlyphIndexArrayNV) New() binary.Object { return &GlPathGlyphIndexArrayNV{} }
func (*binaryClassGlPathGlyphIndexArrayNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathGlyphIndexArrayNV(e, obj.(*GlPathGlyphIndexArrayNV))
}
func (*binaryClassGlPathGlyphIndexArrayNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathGlyphIndexArrayNV{}
	return obj, doDecodeGlPathGlyphIndexArrayNV(d, obj)
}
func (*binaryClassGlPathGlyphIndexArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathGlyphIndexArrayNV(d, obj.(*GlPathGlyphIndexArrayNV))
}
func (*binaryClassGlPathGlyphIndexArrayNV) Skip(d binary.Decoder) error {
	return doSkipGlPathGlyphIndexArrayNV(d)
}
func (*binaryClassGlPathGlyphIndexArrayNV) Schema() *schema.Class {
	return schemaGlPathGlyphIndexArrayNV
}

var schemaGlPathGlyphIndexArrayNV = &schema.Class{
	TypeID:  binaryIDGlPathGlyphIndexArrayNV,
	Package: "gles",
	Name:    "GlPathGlyphIndexArrayNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FirstPathName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FontTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FontName", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "FontStyle", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "FirstGlyphIndex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumGlyphs", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathParameterTemplate", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "EmScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlPathGlyphIndexRangeNV struct{}

func (*GlPathGlyphIndexRangeNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphIndexRangeNV)(nil)
}
func doEncodeGlPathGlyphIndexRangeNV(e binary.Encoder, o *GlPathGlyphIndexRangeNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontTarget)); err != nil {
		return err
	}
	if err := e.Value(&o.FontName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontStyle)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathParameterTemplate)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.EmScale)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BaseAndCount)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathGlyphIndexRangeNV(d binary.Decoder, o *GlPathGlyphIndexRangeNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontTarget = GLenum(obj)
	}
	if err := d.Value(&o.FontName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontStyle = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathParameterTemplate = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.EmScale = GLfloat(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BaseAndCount = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlPathGlyphIndexRangeNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathGlyphIndexRangeNV) ID() binary.ID      { return binaryIDGlPathGlyphIndexRangeNV }
func (*binaryClassGlPathGlyphIndexRangeNV) New() binary.Object { return &GlPathGlyphIndexRangeNV{} }
func (*binaryClassGlPathGlyphIndexRangeNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathGlyphIndexRangeNV(e, obj.(*GlPathGlyphIndexRangeNV))
}
func (*binaryClassGlPathGlyphIndexRangeNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathGlyphIndexRangeNV{}
	return obj, doDecodeGlPathGlyphIndexRangeNV(d, obj)
}
func (*binaryClassGlPathGlyphIndexRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathGlyphIndexRangeNV(d, obj.(*GlPathGlyphIndexRangeNV))
}
func (*binaryClassGlPathGlyphIndexRangeNV) Skip(d binary.Decoder) error {
	return doSkipGlPathGlyphIndexRangeNV(d)
}
func (*binaryClassGlPathGlyphIndexRangeNV) Schema() *schema.Class {
	return schemaGlPathGlyphIndexRangeNV
}

var schemaGlPathGlyphIndexRangeNV = &schema.Class{
	TypeID:  binaryIDGlPathGlyphIndexRangeNV,
	Package: "gles",
	Name:    "GlPathGlyphIndexRangeNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FontTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FontName", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "FontStyle", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "PathParameterTemplate", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "EmScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "BaseAndCount", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlPathGlyphRangeNV struct{}

func (*GlPathGlyphRangeNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphRangeNV)(nil)
}
func doEncodeGlPathGlyphRangeNV(e binary.Encoder, o *GlPathGlyphRangeNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstPathName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontTarget)); err != nil {
		return err
	}
	if err := e.Value(&o.FontName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontStyle)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstGlyph)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.HandleMissingGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathParameterTemplate)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.EmScale)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathGlyphRangeNV(d binary.Decoder, o *GlPathGlyphRangeNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstPathName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontTarget = GLenum(obj)
	}
	if err := d.Value(&o.FontName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontStyle = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstGlyph = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumGlyphs = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.HandleMissingGlyphs = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathParameterTemplate = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.EmScale = GLfloat(obj)
	}
	return nil
}
func doSkipGlPathGlyphRangeNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathGlyphRangeNV) ID() binary.ID      { return binaryIDGlPathGlyphRangeNV }
func (*binaryClassGlPathGlyphRangeNV) New() binary.Object { return &GlPathGlyphRangeNV{} }
func (*binaryClassGlPathGlyphRangeNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathGlyphRangeNV(e, obj.(*GlPathGlyphRangeNV))
}
func (*binaryClassGlPathGlyphRangeNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathGlyphRangeNV{}
	return obj, doDecodeGlPathGlyphRangeNV(d, obj)
}
func (*binaryClassGlPathGlyphRangeNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathGlyphRangeNV(d, obj.(*GlPathGlyphRangeNV))
}
func (*binaryClassGlPathGlyphRangeNV) Skip(d binary.Decoder) error { return doSkipGlPathGlyphRangeNV(d) }
func (*binaryClassGlPathGlyphRangeNV) Schema() *schema.Class       { return schemaGlPathGlyphRangeNV }

var schemaGlPathGlyphRangeNV = &schema.Class{
	TypeID:  binaryIDGlPathGlyphRangeNV,
	Package: "gles",
	Name:    "GlPathGlyphRangeNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FirstPathName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FontTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FontName", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "FontStyle", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "FirstGlyph", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumGlyphs", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "HandleMissingGlyphs", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "PathParameterTemplate", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "EmScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPathGlyphsNV struct{}

func (*GlPathGlyphsNV) Class() binary.Class {
	return (*binaryClassGlPathGlyphsNV)(nil)
}
func doEncodeGlPathGlyphsNV(e binary.Encoder, o *GlPathGlyphsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstPathName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontTarget)); err != nil {
		return err
	}
	if err := e.Value(&o.FontName); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontStyle)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Charcodes); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.HandleMissingGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathParameterTemplate)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.EmScale)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathGlyphsNV(d binary.Decoder, o *GlPathGlyphsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstPathName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontTarget = GLenum(obj)
	}
	if err := d.Value(&o.FontName); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontStyle = GLbitfield(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumGlyphs = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Charcodes); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.HandleMissingGlyphs = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathParameterTemplate = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.EmScale = GLfloat(obj)
	}
	return nil
}
func doSkipGlPathGlyphsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathGlyphsNV) ID() binary.ID      { return binaryIDGlPathGlyphsNV }
func (*binaryClassGlPathGlyphsNV) New() binary.Object { return &GlPathGlyphsNV{} }
func (*binaryClassGlPathGlyphsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathGlyphsNV(e, obj.(*GlPathGlyphsNV))
}
func (*binaryClassGlPathGlyphsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathGlyphsNV{}
	return obj, doDecodeGlPathGlyphsNV(d, obj)
}
func (*binaryClassGlPathGlyphsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathGlyphsNV(d, obj.(*GlPathGlyphsNV))
}
func (*binaryClassGlPathGlyphsNV) Skip(d binary.Decoder) error { return doSkipGlPathGlyphsNV(d) }
func (*binaryClassGlPathGlyphsNV) Schema() *schema.Class       { return schemaGlPathGlyphsNV }

var schemaGlPathGlyphsNV = &schema.Class{
	TypeID:  binaryIDGlPathGlyphsNV,
	Package: "gles",
	Name:    "GlPathGlyphsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FirstPathName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FontTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FontName", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "FontStyle", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "NumGlyphs", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Charcodes", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "HandleMissingGlyphs", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "PathParameterTemplate", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "EmScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPathMemoryGlyphIndexArrayNV struct{}

func (*GlPathMemoryGlyphIndexArrayNV) Class() binary.Class {
	return (*binaryClassGlPathMemoryGlyphIndexArrayNV)(nil)
}
func doEncodeGlPathMemoryGlyphIndexArrayNV(e binary.Encoder, o *GlPathMemoryGlyphIndexArrayNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstPathName)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FontTarget)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.FontSize)); err != nil {
		return err
	}
	if err := e.Value(&o.FontData); err != nil {
		return err
	}
	if err := e.Int32(int32(o.FaceIndex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FirstGlyphIndex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumGlyphs)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathParameterTemplate)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.EmScale)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathMemoryGlyphIndexArrayNV(d binary.Decoder, o *GlPathMemoryGlyphIndexArrayNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstPathName = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FontTarget = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.FontSize = GLsizeiptr(obj)
	}
	if err := d.Value(&o.FontData); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.FaceIndex = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FirstGlyphIndex = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumGlyphs = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathParameterTemplate = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.EmScale = GLfloat(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = GLenum(obj)
	}
	return nil
}
func doSkipGlPathMemoryGlyphIndexArrayNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) ID() binary.ID {
	return binaryIDGlPathMemoryGlyphIndexArrayNV
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) New() binary.Object {
	return &GlPathMemoryGlyphIndexArrayNV{}
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathMemoryGlyphIndexArrayNV(e, obj.(*GlPathMemoryGlyphIndexArrayNV))
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathMemoryGlyphIndexArrayNV{}
	return obj, doDecodeGlPathMemoryGlyphIndexArrayNV(d, obj)
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathMemoryGlyphIndexArrayNV(d, obj.(*GlPathMemoryGlyphIndexArrayNV))
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) Skip(d binary.Decoder) error {
	return doSkipGlPathMemoryGlyphIndexArrayNV(d)
}
func (*binaryClassGlPathMemoryGlyphIndexArrayNV) Schema() *schema.Class {
	return schemaGlPathMemoryGlyphIndexArrayNV
}

var schemaGlPathMemoryGlyphIndexArrayNV = &schema.Class{
	TypeID:  binaryIDGlPathMemoryGlyphIndexArrayNV,
	Package: "gles",
	Name:    "GlPathMemoryGlyphIndexArrayNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "FirstPathName", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FontTarget", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "FontSize", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
		{Declared: "FontData", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "FaceIndex", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "FirstGlyphIndex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumGlyphs", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathParameterTemplate", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "EmScale", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlPathParameterfNV struct{}

func (*GlPathParameterfNV) Class() binary.Class {
	return (*binaryClassGlPathParameterfNV)(nil)
}
func doEncodeGlPathParameterfNV(e binary.Encoder, o *GlPathParameterfNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathParameterfNV(d binary.Decoder, o *GlPathParameterfNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value = GLfloat(obj)
	}
	return nil
}
func doSkipGlPathParameterfNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathParameterfNV) ID() binary.ID      { return binaryIDGlPathParameterfNV }
func (*binaryClassGlPathParameterfNV) New() binary.Object { return &GlPathParameterfNV{} }
func (*binaryClassGlPathParameterfNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathParameterfNV(e, obj.(*GlPathParameterfNV))
}
func (*binaryClassGlPathParameterfNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathParameterfNV{}
	return obj, doDecodeGlPathParameterfNV(d, obj)
}
func (*binaryClassGlPathParameterfNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathParameterfNV(d, obj.(*GlPathParameterfNV))
}
func (*binaryClassGlPathParameterfNV) Skip(d binary.Decoder) error { return doSkipGlPathParameterfNV(d) }
func (*binaryClassGlPathParameterfNV) Schema() *schema.Class       { return schemaGlPathParameterfNV }

var schemaGlPathParameterfNV = &schema.Class{
	TypeID:  binaryIDGlPathParameterfNV,
	Package: "gles",
	Name:    "GlPathParameterfNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPathParameterfvNV struct{}

func (*GlPathParameterfvNV) Class() binary.Class {
	return (*binaryClassGlPathParameterfvNV)(nil)
}
func doEncodeGlPathParameterfvNV(e binary.Encoder, o *GlPathParameterfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathParameterfvNV(d binary.Decoder, o *GlPathParameterfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathParameterfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathParameterfvNV) ID() binary.ID      { return binaryIDGlPathParameterfvNV }
func (*binaryClassGlPathParameterfvNV) New() binary.Object { return &GlPathParameterfvNV{} }
func (*binaryClassGlPathParameterfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathParameterfvNV(e, obj.(*GlPathParameterfvNV))
}
func (*binaryClassGlPathParameterfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathParameterfvNV{}
	return obj, doDecodeGlPathParameterfvNV(d, obj)
}
func (*binaryClassGlPathParameterfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathParameterfvNV(d, obj.(*GlPathParameterfvNV))
}
func (*binaryClassGlPathParameterfvNV) Skip(d binary.Decoder) error {
	return doSkipGlPathParameterfvNV(d)
}
func (*binaryClassGlPathParameterfvNV) Schema() *schema.Class { return schemaGlPathParameterfvNV }

var schemaGlPathParameterfvNV = &schema.Class{
	TypeID:  binaryIDGlPathParameterfvNV,
	Package: "gles",
	Name:    "GlPathParameterfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathParameteriNV struct{}

func (*GlPathParameteriNV) Class() binary.Class {
	return (*binaryClassGlPathParameteriNV)(nil)
}
func doEncodeGlPathParameteriNV(e binary.Encoder, o *GlPathParameteriNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathParameteriNV(d binary.Decoder, o *GlPathParameteriNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlPathParameteriNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathParameteriNV) ID() binary.ID      { return binaryIDGlPathParameteriNV }
func (*binaryClassGlPathParameteriNV) New() binary.Object { return &GlPathParameteriNV{} }
func (*binaryClassGlPathParameteriNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathParameteriNV(e, obj.(*GlPathParameteriNV))
}
func (*binaryClassGlPathParameteriNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathParameteriNV{}
	return obj, doDecodeGlPathParameteriNV(d, obj)
}
func (*binaryClassGlPathParameteriNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathParameteriNV(d, obj.(*GlPathParameteriNV))
}
func (*binaryClassGlPathParameteriNV) Skip(d binary.Decoder) error { return doSkipGlPathParameteriNV(d) }
func (*binaryClassGlPathParameteriNV) Schema() *schema.Class       { return schemaGlPathParameteriNV }

var schemaGlPathParameteriNV = &schema.Class{
	TypeID:  binaryIDGlPathParameteriNV,
	Package: "gles",
	Name:    "GlPathParameteriNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlPathParameterivNV struct{}

func (*GlPathParameterivNV) Class() binary.Class {
	return (*binaryClassGlPathParameterivNV)(nil)
}
func doEncodeGlPathParameterivNV(e binary.Encoder, o *GlPathParameterivNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathParameterivNV(d binary.Decoder, o *GlPathParameterivNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathParameterivNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathParameterivNV) ID() binary.ID      { return binaryIDGlPathParameterivNV }
func (*binaryClassGlPathParameterivNV) New() binary.Object { return &GlPathParameterivNV{} }
func (*binaryClassGlPathParameterivNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathParameterivNV(e, obj.(*GlPathParameterivNV))
}
func (*binaryClassGlPathParameterivNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathParameterivNV{}
	return obj, doDecodeGlPathParameterivNV(d, obj)
}
func (*binaryClassGlPathParameterivNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathParameterivNV(d, obj.(*GlPathParameterivNV))
}
func (*binaryClassGlPathParameterivNV) Skip(d binary.Decoder) error {
	return doSkipGlPathParameterivNV(d)
}
func (*binaryClassGlPathParameterivNV) Schema() *schema.Class { return schemaGlPathParameterivNV }

var schemaGlPathParameterivNV = &schema.Class{
	TypeID:  binaryIDGlPathParameterivNV,
	Package: "gles",
	Name:    "GlPathParameterivNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathStencilDepthOffsetNV struct{}

func (*GlPathStencilDepthOffsetNV) Class() binary.Class {
	return (*binaryClassGlPathStencilDepthOffsetNV)(nil)
}
func doEncodeGlPathStencilDepthOffsetNV(e binary.Encoder, o *GlPathStencilDepthOffsetNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Factor)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Units)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathStencilDepthOffsetNV(d binary.Decoder, o *GlPathStencilDepthOffsetNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Factor = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Units = GLfloat(obj)
	}
	return nil
}
func doSkipGlPathStencilDepthOffsetNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathStencilDepthOffsetNV) ID() binary.ID {
	return binaryIDGlPathStencilDepthOffsetNV
}
func (*binaryClassGlPathStencilDepthOffsetNV) New() binary.Object {
	return &GlPathStencilDepthOffsetNV{}
}
func (*binaryClassGlPathStencilDepthOffsetNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathStencilDepthOffsetNV(e, obj.(*GlPathStencilDepthOffsetNV))
}
func (*binaryClassGlPathStencilDepthOffsetNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathStencilDepthOffsetNV{}
	return obj, doDecodeGlPathStencilDepthOffsetNV(d, obj)
}
func (*binaryClassGlPathStencilDepthOffsetNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathStencilDepthOffsetNV(d, obj.(*GlPathStencilDepthOffsetNV))
}
func (*binaryClassGlPathStencilDepthOffsetNV) Skip(d binary.Decoder) error {
	return doSkipGlPathStencilDepthOffsetNV(d)
}
func (*binaryClassGlPathStencilDepthOffsetNV) Schema() *schema.Class {
	return schemaGlPathStencilDepthOffsetNV
}

var schemaGlPathStencilDepthOffsetNV = &schema.Class{
	TypeID:  binaryIDGlPathStencilDepthOffsetNV,
	Package: "gles",
	Name:    "GlPathStencilDepthOffsetNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Factor", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Units", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPathStencilFuncNV struct{}

func (*GlPathStencilFuncNV) Class() binary.Class {
	return (*binaryClassGlPathStencilFuncNV)(nil)
}
func doEncodeGlPathStencilFuncNV(e binary.Encoder, o *GlPathStencilFuncNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Func)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Ref)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathStencilFuncNV(d binary.Decoder, o *GlPathStencilFuncNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Func = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Ref = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlPathStencilFuncNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathStencilFuncNV) ID() binary.ID      { return binaryIDGlPathStencilFuncNV }
func (*binaryClassGlPathStencilFuncNV) New() binary.Object { return &GlPathStencilFuncNV{} }
func (*binaryClassGlPathStencilFuncNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathStencilFuncNV(e, obj.(*GlPathStencilFuncNV))
}
func (*binaryClassGlPathStencilFuncNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathStencilFuncNV{}
	return obj, doDecodeGlPathStencilFuncNV(d, obj)
}
func (*binaryClassGlPathStencilFuncNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathStencilFuncNV(d, obj.(*GlPathStencilFuncNV))
}
func (*binaryClassGlPathStencilFuncNV) Skip(d binary.Decoder) error {
	return doSkipGlPathStencilFuncNV(d)
}
func (*binaryClassGlPathStencilFuncNV) Schema() *schema.Class { return schemaGlPathStencilFuncNV }

var schemaGlPathStencilFuncNV = &schema.Class{
	TypeID:  binaryIDGlPathStencilFuncNV,
	Package: "gles",
	Name:    "GlPathStencilFuncNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Func", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Ref", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlPathStringNV struct{}

func (*GlPathStringNV) Class() binary.Class {
	return (*binaryClassGlPathStringNV)(nil)
}
func doEncodeGlPathStringNV(e binary.Encoder, o *GlPathStringNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.PathString); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathStringNV(d binary.Decoder, o *GlPathStringNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.PathString); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathStringNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathStringNV) ID() binary.ID      { return binaryIDGlPathStringNV }
func (*binaryClassGlPathStringNV) New() binary.Object { return &GlPathStringNV{} }
func (*binaryClassGlPathStringNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathStringNV(e, obj.(*GlPathStringNV))
}
func (*binaryClassGlPathStringNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathStringNV{}
	return obj, doDecodeGlPathStringNV(d, obj)
}
func (*binaryClassGlPathStringNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathStringNV(d, obj.(*GlPathStringNV))
}
func (*binaryClassGlPathStringNV) Skip(d binary.Decoder) error { return doSkipGlPathStringNV(d) }
func (*binaryClassGlPathStringNV) Schema() *schema.Class       { return schemaGlPathStringNV }

var schemaGlPathStringNV = &schema.Class{
	TypeID:  binaryIDGlPathStringNV,
	Package: "gles",
	Name:    "GlPathStringNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathString", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathSubCommandsNV struct{}

func (*GlPathSubCommandsNV) Class() binary.Class {
	return (*binaryClassGlPathSubCommandsNV)(nil)
}
func doEncodeGlPathSubCommandsNV(e binary.Encoder, o *GlPathSubCommandsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.CommandStart)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.CommandsToDelete)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCommands)); err != nil {
		return err
	}
	if err := e.Value(&o.Commands); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCoords)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoordType)); err != nil {
		return err
	}
	if err := e.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathSubCommandsNV(d binary.Decoder, o *GlPathSubCommandsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.CommandStart = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.CommandsToDelete = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCommands = GLsizei(obj)
	}
	if err := d.Value(&o.Commands); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCoords = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoordType = GLenum(obj)
	}
	if err := d.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathSubCommandsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLubyteᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathSubCommandsNV) ID() binary.ID      { return binaryIDGlPathSubCommandsNV }
func (*binaryClassGlPathSubCommandsNV) New() binary.Object { return &GlPathSubCommandsNV{} }
func (*binaryClassGlPathSubCommandsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathSubCommandsNV(e, obj.(*GlPathSubCommandsNV))
}
func (*binaryClassGlPathSubCommandsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathSubCommandsNV{}
	return obj, doDecodeGlPathSubCommandsNV(d, obj)
}
func (*binaryClassGlPathSubCommandsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathSubCommandsNV(d, obj.(*GlPathSubCommandsNV))
}
func (*binaryClassGlPathSubCommandsNV) Skip(d binary.Decoder) error {
	return doSkipGlPathSubCommandsNV(d)
}
func (*binaryClassGlPathSubCommandsNV) Schema() *schema.Class { return schemaGlPathSubCommandsNV }

var schemaGlPathSubCommandsNV = &schema.Class{
	TypeID:  binaryIDGlPathSubCommandsNV,
	Package: "gles",
	Name:    "GlPathSubCommandsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CommandStart", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "CommandsToDelete", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "NumCommands", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Commands", Type: &schema.Struct{Name: "GLubyteᶜᵖ", ID: (*GLubyteᶜᵖ)(nil).Class().ID()}},
		{Declared: "NumCoords", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "CoordType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Coords", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPathSubCoordsNV struct{}

func (*GlPathSubCoordsNV) Class() binary.Class {
	return (*binaryClassGlPathSubCoordsNV)(nil)
}
func doEncodeGlPathSubCoordsNV(e binary.Encoder, o *GlPathSubCoordsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.CoordStart)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCoords)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoordType)); err != nil {
		return err
	}
	if err := e.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPathSubCoordsNV(d binary.Decoder, o *GlPathSubCoordsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.CoordStart = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCoords = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoordType = GLenum(obj)
	}
	if err := d.Value(&o.Coords); err != nil {
		return err
	}
	return nil
}
func doSkipGlPathSubCoordsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPathSubCoordsNV) ID() binary.ID      { return binaryIDGlPathSubCoordsNV }
func (*binaryClassGlPathSubCoordsNV) New() binary.Object { return &GlPathSubCoordsNV{} }
func (*binaryClassGlPathSubCoordsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPathSubCoordsNV(e, obj.(*GlPathSubCoordsNV))
}
func (*binaryClassGlPathSubCoordsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPathSubCoordsNV{}
	return obj, doDecodeGlPathSubCoordsNV(d, obj)
}
func (*binaryClassGlPathSubCoordsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPathSubCoordsNV(d, obj.(*GlPathSubCoordsNV))
}
func (*binaryClassGlPathSubCoordsNV) Skip(d binary.Decoder) error { return doSkipGlPathSubCoordsNV(d) }
func (*binaryClassGlPathSubCoordsNV) Schema() *schema.Class       { return schemaGlPathSubCoordsNV }

var schemaGlPathSubCoordsNV = &schema.Class{
	TypeID:  binaryIDGlPathSubCoordsNV,
	Package: "gles",
	Name:    "GlPathSubCoordsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoordStart", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "NumCoords", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "CoordType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Coords", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPauseTransformFeedback struct{}

func (*GlPauseTransformFeedback) Class() binary.Class {
	return (*binaryClassGlPauseTransformFeedback)(nil)
}
func doEncodeGlPauseTransformFeedback(e binary.Encoder, o *GlPauseTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPauseTransformFeedback(d binary.Decoder, o *GlPauseTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlPauseTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPauseTransformFeedback) ID() binary.ID      { return binaryIDGlPauseTransformFeedback }
func (*binaryClassGlPauseTransformFeedback) New() binary.Object { return &GlPauseTransformFeedback{} }
func (*binaryClassGlPauseTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPauseTransformFeedback(e, obj.(*GlPauseTransformFeedback))
}
func (*binaryClassGlPauseTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPauseTransformFeedback{}
	return obj, doDecodeGlPauseTransformFeedback(d, obj)
}
func (*binaryClassGlPauseTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPauseTransformFeedback(d, obj.(*GlPauseTransformFeedback))
}
func (*binaryClassGlPauseTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlPauseTransformFeedback(d)
}
func (*binaryClassGlPauseTransformFeedback) Schema() *schema.Class {
	return schemaGlPauseTransformFeedback
}

var schemaGlPauseTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlPauseTransformFeedback,
	Package: "gles",
	Name:    "GlPauseTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlPixelStorei struct{}

func (*GlPixelStorei) Class() binary.Class {
	return (*binaryClassGlPixelStorei)(nil)
}
func doEncodeGlPixelStorei(e binary.Encoder, o *GlPixelStorei) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPixelStorei(d binary.Decoder, o *GlPixelStorei) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlPixelStorei(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPixelStorei) ID() binary.ID      { return binaryIDGlPixelStorei }
func (*binaryClassGlPixelStorei) New() binary.Object { return &GlPixelStorei{} }
func (*binaryClassGlPixelStorei) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPixelStorei(e, obj.(*GlPixelStorei))
}
func (*binaryClassGlPixelStorei) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPixelStorei{}
	return obj, doDecodeGlPixelStorei(d, obj)
}
func (*binaryClassGlPixelStorei) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPixelStorei(d, obj.(*GlPixelStorei))
}
func (*binaryClassGlPixelStorei) Skip(d binary.Decoder) error { return doSkipGlPixelStorei(d) }
func (*binaryClassGlPixelStorei) Schema() *schema.Class       { return schemaGlPixelStorei }

var schemaGlPixelStorei = &schema.Class{
	TypeID:  binaryIDGlPixelStorei,
	Package: "gles",
	Name:    "GlPixelStorei",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlPointAlongPathNV struct{}

func (*GlPointAlongPathNV) Class() binary.Class {
	return (*binaryClassGlPointAlongPathNV)(nil)
}
func doEncodeGlPointAlongPathNV(e binary.Encoder, o *GlPointAlongPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.StartSegment)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumSegments)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Distance)); err != nil {
		return err
	}
	if err := e.Value(&o.X); err != nil {
		return err
	}
	if err := e.Value(&o.Y); err != nil {
		return err
	}
	if err := e.Value(&o.TangentX); err != nil {
		return err
	}
	if err := e.Value(&o.TangentY); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPointAlongPathNV(d binary.Decoder, o *GlPointAlongPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.StartSegment = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumSegments = GLsizei(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Distance = GLfloat(obj)
	}
	if err := d.Value(&o.X); err != nil {
		return err
	}
	if err := d.Value(&o.Y); err != nil {
		return err
	}
	if err := d.Value(&o.TangentX); err != nil {
		return err
	}
	if err := d.Value(&o.TangentY); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlPointAlongPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPointAlongPathNV) ID() binary.ID      { return binaryIDGlPointAlongPathNV }
func (*binaryClassGlPointAlongPathNV) New() binary.Object { return &GlPointAlongPathNV{} }
func (*binaryClassGlPointAlongPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPointAlongPathNV(e, obj.(*GlPointAlongPathNV))
}
func (*binaryClassGlPointAlongPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPointAlongPathNV{}
	return obj, doDecodeGlPointAlongPathNV(d, obj)
}
func (*binaryClassGlPointAlongPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPointAlongPathNV(d, obj.(*GlPointAlongPathNV))
}
func (*binaryClassGlPointAlongPathNV) Skip(d binary.Decoder) error { return doSkipGlPointAlongPathNV(d) }
func (*binaryClassGlPointAlongPathNV) Schema() *schema.Class       { return schemaGlPointAlongPathNV }

var schemaGlPointAlongPathNV = &schema.Class{
	TypeID:  binaryIDGlPointAlongPathNV,
	Package: "gles",
	Name:    "GlPointAlongPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "StartSegment", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "NumSegments", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Distance", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "X", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
		{Declared: "Y", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
		{Declared: "TangentX", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
		{Declared: "TangentY", Type: &schema.Struct{Name: "GLfloatᵖ", ID: (*GLfloatᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlPolygonModeNV struct{}

func (*GlPolygonModeNV) Class() binary.Class {
	return (*binaryClassGlPolygonModeNV)(nil)
}
func doEncodeGlPolygonModeNV(e binary.Encoder, o *GlPolygonModeNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Face)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPolygonModeNV(d binary.Decoder, o *GlPolygonModeNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Face = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlPolygonModeNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPolygonModeNV) ID() binary.ID      { return binaryIDGlPolygonModeNV }
func (*binaryClassGlPolygonModeNV) New() binary.Object { return &GlPolygonModeNV{} }
func (*binaryClassGlPolygonModeNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPolygonModeNV(e, obj.(*GlPolygonModeNV))
}
func (*binaryClassGlPolygonModeNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPolygonModeNV{}
	return obj, doDecodeGlPolygonModeNV(d, obj)
}
func (*binaryClassGlPolygonModeNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPolygonModeNV(d, obj.(*GlPolygonModeNV))
}
func (*binaryClassGlPolygonModeNV) Skip(d binary.Decoder) error { return doSkipGlPolygonModeNV(d) }
func (*binaryClassGlPolygonModeNV) Schema() *schema.Class       { return schemaGlPolygonModeNV }

var schemaGlPolygonModeNV = &schema.Class{
	TypeID:  binaryIDGlPolygonModeNV,
	Package: "gles",
	Name:    "GlPolygonModeNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Face", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlPolygonOffset struct{}

func (*GlPolygonOffset) Class() binary.Class {
	return (*binaryClassGlPolygonOffset)(nil)
}
func doEncodeGlPolygonOffset(e binary.Encoder, o *GlPolygonOffset) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.ScaleFactor)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Units)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPolygonOffset(d binary.Decoder, o *GlPolygonOffset) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.ScaleFactor = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Units = GLfloat(obj)
	}
	return nil
}
func doSkipGlPolygonOffset(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPolygonOffset) ID() binary.ID      { return binaryIDGlPolygonOffset }
func (*binaryClassGlPolygonOffset) New() binary.Object { return &GlPolygonOffset{} }
func (*binaryClassGlPolygonOffset) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPolygonOffset(e, obj.(*GlPolygonOffset))
}
func (*binaryClassGlPolygonOffset) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPolygonOffset{}
	return obj, doDecodeGlPolygonOffset(d, obj)
}
func (*binaryClassGlPolygonOffset) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPolygonOffset(d, obj.(*GlPolygonOffset))
}
func (*binaryClassGlPolygonOffset) Skip(d binary.Decoder) error { return doSkipGlPolygonOffset(d) }
func (*binaryClassGlPolygonOffset) Schema() *schema.Class       { return schemaGlPolygonOffset }

var schemaGlPolygonOffset = &schema.Class{
	TypeID:  binaryIDGlPolygonOffset,
	Package: "gles",
	Name:    "GlPolygonOffset",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ScaleFactor", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Units", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPopDebugGroupKHR struct{}

func (*GlPopDebugGroupKHR) Class() binary.Class {
	return (*binaryClassGlPopDebugGroupKHR)(nil)
}
func doEncodeGlPopDebugGroupKHR(e binary.Encoder, o *GlPopDebugGroupKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPopDebugGroupKHR(d binary.Decoder, o *GlPopDebugGroupKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlPopDebugGroupKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPopDebugGroupKHR) ID() binary.ID      { return binaryIDGlPopDebugGroupKHR }
func (*binaryClassGlPopDebugGroupKHR) New() binary.Object { return &GlPopDebugGroupKHR{} }
func (*binaryClassGlPopDebugGroupKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPopDebugGroupKHR(e, obj.(*GlPopDebugGroupKHR))
}
func (*binaryClassGlPopDebugGroupKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPopDebugGroupKHR{}
	return obj, doDecodeGlPopDebugGroupKHR(d, obj)
}
func (*binaryClassGlPopDebugGroupKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPopDebugGroupKHR(d, obj.(*GlPopDebugGroupKHR))
}
func (*binaryClassGlPopDebugGroupKHR) Skip(d binary.Decoder) error { return doSkipGlPopDebugGroupKHR(d) }
func (*binaryClassGlPopDebugGroupKHR) Schema() *schema.Class       { return schemaGlPopDebugGroupKHR }

var schemaGlPopDebugGroupKHR = &schema.Class{
	TypeID:  binaryIDGlPopDebugGroupKHR,
	Package: "gles",
	Name:    "GlPopDebugGroupKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlPopGroupMarkerEXT struct{}

func (*GlPopGroupMarkerEXT) Class() binary.Class {
	return (*binaryClassGlPopGroupMarkerEXT)(nil)
}
func doEncodeGlPopGroupMarkerEXT(e binary.Encoder, o *GlPopGroupMarkerEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPopGroupMarkerEXT(d binary.Decoder, o *GlPopGroupMarkerEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlPopGroupMarkerEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPopGroupMarkerEXT) ID() binary.ID      { return binaryIDGlPopGroupMarkerEXT }
func (*binaryClassGlPopGroupMarkerEXT) New() binary.Object { return &GlPopGroupMarkerEXT{} }
func (*binaryClassGlPopGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPopGroupMarkerEXT(e, obj.(*GlPopGroupMarkerEXT))
}
func (*binaryClassGlPopGroupMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPopGroupMarkerEXT{}
	return obj, doDecodeGlPopGroupMarkerEXT(d, obj)
}
func (*binaryClassGlPopGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPopGroupMarkerEXT(d, obj.(*GlPopGroupMarkerEXT))
}
func (*binaryClassGlPopGroupMarkerEXT) Skip(d binary.Decoder) error {
	return doSkipGlPopGroupMarkerEXT(d)
}
func (*binaryClassGlPopGroupMarkerEXT) Schema() *schema.Class { return schemaGlPopGroupMarkerEXT }

var schemaGlPopGroupMarkerEXT = &schema.Class{
	TypeID:  binaryIDGlPopGroupMarkerEXT,
	Package: "gles",
	Name:    "GlPopGroupMarkerEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlPrimitiveBoundingBoxEXT struct{}

func (*GlPrimitiveBoundingBoxEXT) Class() binary.Class {
	return (*binaryClassGlPrimitiveBoundingBoxEXT)(nil)
}
func doEncodeGlPrimitiveBoundingBoxEXT(e binary.Encoder, o *GlPrimitiveBoundingBoxEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinX)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinY)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinZ)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinW)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxX)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxY)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxZ)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxW)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPrimitiveBoundingBoxEXT(d binary.Decoder, o *GlPrimitiveBoundingBoxEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinX = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinY = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinZ = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinW = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxX = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxY = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxZ = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxW = GLfloat(obj)
	}
	return nil
}
func doSkipGlPrimitiveBoundingBoxEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) ID() binary.ID      { return binaryIDGlPrimitiveBoundingBoxEXT }
func (*binaryClassGlPrimitiveBoundingBoxEXT) New() binary.Object { return &GlPrimitiveBoundingBoxEXT{} }
func (*binaryClassGlPrimitiveBoundingBoxEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPrimitiveBoundingBoxEXT(e, obj.(*GlPrimitiveBoundingBoxEXT))
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPrimitiveBoundingBoxEXT{}
	return obj, doDecodeGlPrimitiveBoundingBoxEXT(d, obj)
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPrimitiveBoundingBoxEXT(d, obj.(*GlPrimitiveBoundingBoxEXT))
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) Skip(d binary.Decoder) error {
	return doSkipGlPrimitiveBoundingBoxEXT(d)
}
func (*binaryClassGlPrimitiveBoundingBoxEXT) Schema() *schema.Class {
	return schemaGlPrimitiveBoundingBoxEXT
}

var schemaGlPrimitiveBoundingBoxEXT = &schema.Class{
	TypeID:  binaryIDGlPrimitiveBoundingBoxEXT,
	Package: "gles",
	Name:    "GlPrimitiveBoundingBoxEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MinX", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinY", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinZ", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinW", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxX", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxY", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxZ", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxW", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlPrimitiveBoundingBoxOES struct{}

func (*GlPrimitiveBoundingBoxOES) Class() binary.Class {
	return (*binaryClassGlPrimitiveBoundingBoxOES)(nil)
}
func doEncodeGlPrimitiveBoundingBoxOES(e binary.Encoder, o *GlPrimitiveBoundingBoxOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinX)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinY)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinZ)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MinW)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxX)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxY)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxZ)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.MaxW)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPrimitiveBoundingBoxOES(d binary.Decoder, o *GlPrimitiveBoundingBoxOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinX = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinY = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinZ = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MinW = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxX = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxY = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxZ = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.MaxW = GLfloat(obj)
	}
	return nil
}
func doSkipGlPrimitiveBoundingBoxOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPrimitiveBoundingBoxOES) ID() binary.ID      { return binaryIDGlPrimitiveBoundingBoxOES }
func (*binaryClassGlPrimitiveBoundingBoxOES) New() binary.Object { return &GlPrimitiveBoundingBoxOES{} }
func (*binaryClassGlPrimitiveBoundingBoxOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPrimitiveBoundingBoxOES(e, obj.(*GlPrimitiveBoundingBoxOES))
}
func (*binaryClassGlPrimitiveBoundingBoxOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPrimitiveBoundingBoxOES{}
	return obj, doDecodeGlPrimitiveBoundingBoxOES(d, obj)
}
func (*binaryClassGlPrimitiveBoundingBoxOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPrimitiveBoundingBoxOES(d, obj.(*GlPrimitiveBoundingBoxOES))
}
func (*binaryClassGlPrimitiveBoundingBoxOES) Skip(d binary.Decoder) error {
	return doSkipGlPrimitiveBoundingBoxOES(d)
}
func (*binaryClassGlPrimitiveBoundingBoxOES) Schema() *schema.Class {
	return schemaGlPrimitiveBoundingBoxOES
}

var schemaGlPrimitiveBoundingBoxOES = &schema.Class{
	TypeID:  binaryIDGlPrimitiveBoundingBoxOES,
	Package: "gles",
	Name:    "GlPrimitiveBoundingBoxOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MinX", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinY", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinZ", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MinW", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxX", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxY", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxZ", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "MaxW", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramBinary struct{}

func (*GlProgramBinary) Class() binary.Class {
	return (*binaryClassGlProgramBinary)(nil)
}
func doEncodeGlProgramBinary(e binary.Encoder, o *GlProgramBinary) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BinaryFormat)); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramBinary(d binary.Decoder, o *GlProgramBinary) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BinaryFormat = GLenum(obj)
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	return nil
}
func doSkipGlProgramBinary(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramBinary) ID() binary.ID      { return binaryIDGlProgramBinary }
func (*binaryClassGlProgramBinary) New() binary.Object { return &GlProgramBinary{} }
func (*binaryClassGlProgramBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramBinary(e, obj.(*GlProgramBinary))
}
func (*binaryClassGlProgramBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramBinary{}
	return obj, doDecodeGlProgramBinary(d, obj)
}
func (*binaryClassGlProgramBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramBinary(d, obj.(*GlProgramBinary))
}
func (*binaryClassGlProgramBinary) Skip(d binary.Decoder) error { return doSkipGlProgramBinary(d) }
func (*binaryClassGlProgramBinary) Schema() *schema.Class       { return schemaGlProgramBinary }

var schemaGlProgramBinary = &schema.Class{
	TypeID:  binaryIDGlProgramBinary,
	Package: "gles",
	Name:    "GlProgramBinary",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BinaryFormat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Binary", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlProgramBinaryOES struct{}

func (*GlProgramBinaryOES) Class() binary.Class {
	return (*binaryClassGlProgramBinaryOES)(nil)
}
func doEncodeGlProgramBinaryOES(e binary.Encoder, o *GlProgramBinaryOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BinaryFormat)); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BinarySize)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramBinaryOES(d binary.Decoder, o *GlProgramBinaryOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BinaryFormat = GLenum(obj)
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BinarySize = GLint(obj)
	}
	return nil
}
func doSkipGlProgramBinaryOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramBinaryOES) ID() binary.ID      { return binaryIDGlProgramBinaryOES }
func (*binaryClassGlProgramBinaryOES) New() binary.Object { return &GlProgramBinaryOES{} }
func (*binaryClassGlProgramBinaryOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramBinaryOES(e, obj.(*GlProgramBinaryOES))
}
func (*binaryClassGlProgramBinaryOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramBinaryOES{}
	return obj, doDecodeGlProgramBinaryOES(d, obj)
}
func (*binaryClassGlProgramBinaryOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramBinaryOES(d, obj.(*GlProgramBinaryOES))
}
func (*binaryClassGlProgramBinaryOES) Skip(d binary.Decoder) error { return doSkipGlProgramBinaryOES(d) }
func (*binaryClassGlProgramBinaryOES) Schema() *schema.Class       { return schemaGlProgramBinaryOES }

var schemaGlProgramBinaryOES = &schema.Class{
	TypeID:  binaryIDGlProgramBinaryOES,
	Package: "gles",
	Name:    "GlProgramBinaryOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "BinaryFormat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Binary", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "BinarySize", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramParameteri struct{}

func (*GlProgramParameteri) Class() binary.Class {
	return (*binaryClassGlProgramParameteri)(nil)
}
func doEncodeGlProgramParameteri(e binary.Encoder, o *GlProgramParameteri) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramParameteri(d binary.Decoder, o *GlProgramParameteri) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlProgramParameteri(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramParameteri) ID() binary.ID      { return binaryIDGlProgramParameteri }
func (*binaryClassGlProgramParameteri) New() binary.Object { return &GlProgramParameteri{} }
func (*binaryClassGlProgramParameteri) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramParameteri(e, obj.(*GlProgramParameteri))
}
func (*binaryClassGlProgramParameteri) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramParameteri{}
	return obj, doDecodeGlProgramParameteri(d, obj)
}
func (*binaryClassGlProgramParameteri) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramParameteri(d, obj.(*GlProgramParameteri))
}
func (*binaryClassGlProgramParameteri) Skip(d binary.Decoder) error {
	return doSkipGlProgramParameteri(d)
}
func (*binaryClassGlProgramParameteri) Schema() *schema.Class { return schemaGlProgramParameteri }

var schemaGlProgramParameteri = &schema.Class{
	TypeID:  binaryIDGlProgramParameteri,
	Package: "gles",
	Name:    "GlProgramParameteri",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramParameteriEXT struct{}

func (*GlProgramParameteriEXT) Class() binary.Class {
	return (*binaryClassGlProgramParameteriEXT)(nil)
}
func doEncodeGlProgramParameteriEXT(e binary.Encoder, o *GlProgramParameteriEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramParameteriEXT(d binary.Decoder, o *GlProgramParameteriEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlProgramParameteriEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramParameteriEXT) ID() binary.ID      { return binaryIDGlProgramParameteriEXT }
func (*binaryClassGlProgramParameteriEXT) New() binary.Object { return &GlProgramParameteriEXT{} }
func (*binaryClassGlProgramParameteriEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramParameteriEXT(e, obj.(*GlProgramParameteriEXT))
}
func (*binaryClassGlProgramParameteriEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramParameteriEXT{}
	return obj, doDecodeGlProgramParameteriEXT(d, obj)
}
func (*binaryClassGlProgramParameteriEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramParameteriEXT(d, obj.(*GlProgramParameteriEXT))
}
func (*binaryClassGlProgramParameteriEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramParameteriEXT(d)
}
func (*binaryClassGlProgramParameteriEXT) Schema() *schema.Class { return schemaGlProgramParameteriEXT }

var schemaGlProgramParameteriEXT = &schema.Class{
	TypeID:  binaryIDGlProgramParameteriEXT,
	Package: "gles",
	Name:    "GlProgramParameteriEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramPathFragmentInputGenNV struct{}

func (*GlProgramPathFragmentInputGenNV) Class() binary.Class {
	return (*binaryClassGlProgramPathFragmentInputGenNV)(nil)
}
func doEncodeGlProgramPathFragmentInputGenNV(e binary.Encoder, o *GlProgramPathFragmentInputGenNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.GenMode)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Components)); err != nil {
		return err
	}
	if err := e.Value(&o.Coeffs); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramPathFragmentInputGenNV(d binary.Decoder, o *GlProgramPathFragmentInputGenNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.GenMode = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Components = GLint(obj)
	}
	if err := d.Value(&o.Coeffs); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramPathFragmentInputGenNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramPathFragmentInputGenNV) ID() binary.ID {
	return binaryIDGlProgramPathFragmentInputGenNV
}
func (*binaryClassGlProgramPathFragmentInputGenNV) New() binary.Object {
	return &GlProgramPathFragmentInputGenNV{}
}
func (*binaryClassGlProgramPathFragmentInputGenNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramPathFragmentInputGenNV(e, obj.(*GlProgramPathFragmentInputGenNV))
}
func (*binaryClassGlProgramPathFragmentInputGenNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramPathFragmentInputGenNV{}
	return obj, doDecodeGlProgramPathFragmentInputGenNV(d, obj)
}
func (*binaryClassGlProgramPathFragmentInputGenNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramPathFragmentInputGenNV(d, obj.(*GlProgramPathFragmentInputGenNV))
}
func (*binaryClassGlProgramPathFragmentInputGenNV) Skip(d binary.Decoder) error {
	return doSkipGlProgramPathFragmentInputGenNV(d)
}
func (*binaryClassGlProgramPathFragmentInputGenNV) Schema() *schema.Class {
	return schemaGlProgramPathFragmentInputGenNV
}

var schemaGlProgramPathFragmentInputGenNV = &schema.Class{
	TypeID:  binaryIDGlProgramPathFragmentInputGenNV,
	Package: "gles",
	Name:    "GlProgramPathFragmentInputGenNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "GenMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Components", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Coeffs", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1f struct{}

func (*GlProgramUniform1f) Class() binary.Class {
	return (*binaryClassGlProgramUniform1f)(nil)
}
func doEncodeGlProgramUniform1f(e binary.Encoder, o *GlProgramUniform1f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1f(d binary.Decoder, o *GlProgramUniform1f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform1f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1f) ID() binary.ID      { return binaryIDGlProgramUniform1f }
func (*binaryClassGlProgramUniform1f) New() binary.Object { return &GlProgramUniform1f{} }
func (*binaryClassGlProgramUniform1f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1f(e, obj.(*GlProgramUniform1f))
}
func (*binaryClassGlProgramUniform1f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1f{}
	return obj, doDecodeGlProgramUniform1f(d, obj)
}
func (*binaryClassGlProgramUniform1f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1f(d, obj.(*GlProgramUniform1f))
}
func (*binaryClassGlProgramUniform1f) Skip(d binary.Decoder) error { return doSkipGlProgramUniform1f(d) }
func (*binaryClassGlProgramUniform1f) Schema() *schema.Class       { return schemaGlProgramUniform1f }

var schemaGlProgramUniform1f = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1f,
	Package: "gles",
	Name:    "GlProgramUniform1f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform1fEXT struct{}

func (*GlProgramUniform1fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fEXT)(nil)
}
func doEncodeGlProgramUniform1fEXT(e binary.Encoder, o *GlProgramUniform1fEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1fEXT(d binary.Decoder, o *GlProgramUniform1fEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform1fEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1fEXT) ID() binary.ID      { return binaryIDGlProgramUniform1fEXT }
func (*binaryClassGlProgramUniform1fEXT) New() binary.Object { return &GlProgramUniform1fEXT{} }
func (*binaryClassGlProgramUniform1fEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1fEXT(e, obj.(*GlProgramUniform1fEXT))
}
func (*binaryClassGlProgramUniform1fEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1fEXT{}
	return obj, doDecodeGlProgramUniform1fEXT(d, obj)
}
func (*binaryClassGlProgramUniform1fEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1fEXT(d, obj.(*GlProgramUniform1fEXT))
}
func (*binaryClassGlProgramUniform1fEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1fEXT(d)
}
func (*binaryClassGlProgramUniform1fEXT) Schema() *schema.Class { return schemaGlProgramUniform1fEXT }

var schemaGlProgramUniform1fEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1fEXT,
	Package: "gles",
	Name:    "GlProgramUniform1fEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform1fv struct{}

func (*GlProgramUniform1fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fv)(nil)
}
func doEncodeGlProgramUniform1fv(e binary.Encoder, o *GlProgramUniform1fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1fv(d binary.Decoder, o *GlProgramUniform1fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1fv) ID() binary.ID      { return binaryIDGlProgramUniform1fv }
func (*binaryClassGlProgramUniform1fv) New() binary.Object { return &GlProgramUniform1fv{} }
func (*binaryClassGlProgramUniform1fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1fv(e, obj.(*GlProgramUniform1fv))
}
func (*binaryClassGlProgramUniform1fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1fv{}
	return obj, doDecodeGlProgramUniform1fv(d, obj)
}
func (*binaryClassGlProgramUniform1fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1fv(d, obj.(*GlProgramUniform1fv))
}
func (*binaryClassGlProgramUniform1fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1fv(d)
}
func (*binaryClassGlProgramUniform1fv) Schema() *schema.Class { return schemaGlProgramUniform1fv }

var schemaGlProgramUniform1fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1fv,
	Package: "gles",
	Name:    "GlProgramUniform1fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1fvEXT struct{}

func (*GlProgramUniform1fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1fvEXT)(nil)
}
func doEncodeGlProgramUniform1fvEXT(e binary.Encoder, o *GlProgramUniform1fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1fvEXT(d binary.Decoder, o *GlProgramUniform1fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1fvEXT) ID() binary.ID      { return binaryIDGlProgramUniform1fvEXT }
func (*binaryClassGlProgramUniform1fvEXT) New() binary.Object { return &GlProgramUniform1fvEXT{} }
func (*binaryClassGlProgramUniform1fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1fvEXT(e, obj.(*GlProgramUniform1fvEXT))
}
func (*binaryClassGlProgramUniform1fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1fvEXT{}
	return obj, doDecodeGlProgramUniform1fvEXT(d, obj)
}
func (*binaryClassGlProgramUniform1fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1fvEXT(d, obj.(*GlProgramUniform1fvEXT))
}
func (*binaryClassGlProgramUniform1fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1fvEXT(d)
}
func (*binaryClassGlProgramUniform1fvEXT) Schema() *schema.Class { return schemaGlProgramUniform1fvEXT }

var schemaGlProgramUniform1fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1fvEXT,
	Package: "gles",
	Name:    "GlProgramUniform1fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1i struct{}

func (*GlProgramUniform1i) Class() binary.Class {
	return (*binaryClassGlProgramUniform1i)(nil)
}
func doEncodeGlProgramUniform1i(e binary.Encoder, o *GlProgramUniform1i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1i(d binary.Decoder, o *GlProgramUniform1i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform1i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1i) ID() binary.ID      { return binaryIDGlProgramUniform1i }
func (*binaryClassGlProgramUniform1i) New() binary.Object { return &GlProgramUniform1i{} }
func (*binaryClassGlProgramUniform1i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1i(e, obj.(*GlProgramUniform1i))
}
func (*binaryClassGlProgramUniform1i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1i{}
	return obj, doDecodeGlProgramUniform1i(d, obj)
}
func (*binaryClassGlProgramUniform1i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1i(d, obj.(*GlProgramUniform1i))
}
func (*binaryClassGlProgramUniform1i) Skip(d binary.Decoder) error { return doSkipGlProgramUniform1i(d) }
func (*binaryClassGlProgramUniform1i) Schema() *schema.Class       { return schemaGlProgramUniform1i }

var schemaGlProgramUniform1i = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1i,
	Package: "gles",
	Name:    "GlProgramUniform1i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform1iEXT struct{}

func (*GlProgramUniform1iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1iEXT)(nil)
}
func doEncodeGlProgramUniform1iEXT(e binary.Encoder, o *GlProgramUniform1iEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1iEXT(d binary.Decoder, o *GlProgramUniform1iEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform1iEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1iEXT) ID() binary.ID      { return binaryIDGlProgramUniform1iEXT }
func (*binaryClassGlProgramUniform1iEXT) New() binary.Object { return &GlProgramUniform1iEXT{} }
func (*binaryClassGlProgramUniform1iEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1iEXT(e, obj.(*GlProgramUniform1iEXT))
}
func (*binaryClassGlProgramUniform1iEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1iEXT{}
	return obj, doDecodeGlProgramUniform1iEXT(d, obj)
}
func (*binaryClassGlProgramUniform1iEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1iEXT(d, obj.(*GlProgramUniform1iEXT))
}
func (*binaryClassGlProgramUniform1iEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1iEXT(d)
}
func (*binaryClassGlProgramUniform1iEXT) Schema() *schema.Class { return schemaGlProgramUniform1iEXT }

var schemaGlProgramUniform1iEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1iEXT,
	Package: "gles",
	Name:    "GlProgramUniform1iEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform1iv struct{}

func (*GlProgramUniform1iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1iv)(nil)
}
func doEncodeGlProgramUniform1iv(e binary.Encoder, o *GlProgramUniform1iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1iv(d binary.Decoder, o *GlProgramUniform1iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1iv) ID() binary.ID      { return binaryIDGlProgramUniform1iv }
func (*binaryClassGlProgramUniform1iv) New() binary.Object { return &GlProgramUniform1iv{} }
func (*binaryClassGlProgramUniform1iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1iv(e, obj.(*GlProgramUniform1iv))
}
func (*binaryClassGlProgramUniform1iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1iv{}
	return obj, doDecodeGlProgramUniform1iv(d, obj)
}
func (*binaryClassGlProgramUniform1iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1iv(d, obj.(*GlProgramUniform1iv))
}
func (*binaryClassGlProgramUniform1iv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1iv(d)
}
func (*binaryClassGlProgramUniform1iv) Schema() *schema.Class { return schemaGlProgramUniform1iv }

var schemaGlProgramUniform1iv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1iv,
	Package: "gles",
	Name:    "GlProgramUniform1iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1ivEXT struct{}

func (*GlProgramUniform1ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1ivEXT)(nil)
}
func doEncodeGlProgramUniform1ivEXT(e binary.Encoder, o *GlProgramUniform1ivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1ivEXT(d binary.Decoder, o *GlProgramUniform1ivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1ivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1ivEXT) ID() binary.ID      { return binaryIDGlProgramUniform1ivEXT }
func (*binaryClassGlProgramUniform1ivEXT) New() binary.Object { return &GlProgramUniform1ivEXT{} }
func (*binaryClassGlProgramUniform1ivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1ivEXT(e, obj.(*GlProgramUniform1ivEXT))
}
func (*binaryClassGlProgramUniform1ivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1ivEXT{}
	return obj, doDecodeGlProgramUniform1ivEXT(d, obj)
}
func (*binaryClassGlProgramUniform1ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1ivEXT(d, obj.(*GlProgramUniform1ivEXT))
}
func (*binaryClassGlProgramUniform1ivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1ivEXT(d)
}
func (*binaryClassGlProgramUniform1ivEXT) Schema() *schema.Class { return schemaGlProgramUniform1ivEXT }

var schemaGlProgramUniform1ivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1ivEXT,
	Package: "gles",
	Name:    "GlProgramUniform1ivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1ui struct{}

func (*GlProgramUniform1ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform1ui)(nil)
}
func doEncodeGlProgramUniform1ui(e binary.Encoder, o *GlProgramUniform1ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1ui(d binary.Decoder, o *GlProgramUniform1ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform1ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1ui) ID() binary.ID      { return binaryIDGlProgramUniform1ui }
func (*binaryClassGlProgramUniform1ui) New() binary.Object { return &GlProgramUniform1ui{} }
func (*binaryClassGlProgramUniform1ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1ui(e, obj.(*GlProgramUniform1ui))
}
func (*binaryClassGlProgramUniform1ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1ui{}
	return obj, doDecodeGlProgramUniform1ui(d, obj)
}
func (*binaryClassGlProgramUniform1ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1ui(d, obj.(*GlProgramUniform1ui))
}
func (*binaryClassGlProgramUniform1ui) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1ui(d)
}
func (*binaryClassGlProgramUniform1ui) Schema() *schema.Class { return schemaGlProgramUniform1ui }

var schemaGlProgramUniform1ui = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1ui,
	Package: "gles",
	Name:    "GlProgramUniform1ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform1uiEXT struct{}

func (*GlProgramUniform1uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uiEXT)(nil)
}
func doEncodeGlProgramUniform1uiEXT(e binary.Encoder, o *GlProgramUniform1uiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1uiEXT(d binary.Decoder, o *GlProgramUniform1uiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform1uiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1uiEXT) ID() binary.ID      { return binaryIDGlProgramUniform1uiEXT }
func (*binaryClassGlProgramUniform1uiEXT) New() binary.Object { return &GlProgramUniform1uiEXT{} }
func (*binaryClassGlProgramUniform1uiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1uiEXT(e, obj.(*GlProgramUniform1uiEXT))
}
func (*binaryClassGlProgramUniform1uiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1uiEXT{}
	return obj, doDecodeGlProgramUniform1uiEXT(d, obj)
}
func (*binaryClassGlProgramUniform1uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1uiEXT(d, obj.(*GlProgramUniform1uiEXT))
}
func (*binaryClassGlProgramUniform1uiEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1uiEXT(d)
}
func (*binaryClassGlProgramUniform1uiEXT) Schema() *schema.Class { return schemaGlProgramUniform1uiEXT }

var schemaGlProgramUniform1uiEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1uiEXT,
	Package: "gles",
	Name:    "GlProgramUniform1uiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform1uiv struct{}

func (*GlProgramUniform1uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uiv)(nil)
}
func doEncodeGlProgramUniform1uiv(e binary.Encoder, o *GlProgramUniform1uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1uiv(d binary.Decoder, o *GlProgramUniform1uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1uiv) ID() binary.ID      { return binaryIDGlProgramUniform1uiv }
func (*binaryClassGlProgramUniform1uiv) New() binary.Object { return &GlProgramUniform1uiv{} }
func (*binaryClassGlProgramUniform1uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1uiv(e, obj.(*GlProgramUniform1uiv))
}
func (*binaryClassGlProgramUniform1uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1uiv{}
	return obj, doDecodeGlProgramUniform1uiv(d, obj)
}
func (*binaryClassGlProgramUniform1uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1uiv(d, obj.(*GlProgramUniform1uiv))
}
func (*binaryClassGlProgramUniform1uiv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1uiv(d)
}
func (*binaryClassGlProgramUniform1uiv) Schema() *schema.Class { return schemaGlProgramUniform1uiv }

var schemaGlProgramUniform1uiv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1uiv,
	Package: "gles",
	Name:    "GlProgramUniform1uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform1uivEXT struct{}

func (*GlProgramUniform1uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform1uivEXT)(nil)
}
func doEncodeGlProgramUniform1uivEXT(e binary.Encoder, o *GlProgramUniform1uivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform1uivEXT(d binary.Decoder, o *GlProgramUniform1uivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform1uivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform1uivEXT) ID() binary.ID      { return binaryIDGlProgramUniform1uivEXT }
func (*binaryClassGlProgramUniform1uivEXT) New() binary.Object { return &GlProgramUniform1uivEXT{} }
func (*binaryClassGlProgramUniform1uivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform1uivEXT(e, obj.(*GlProgramUniform1uivEXT))
}
func (*binaryClassGlProgramUniform1uivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform1uivEXT{}
	return obj, doDecodeGlProgramUniform1uivEXT(d, obj)
}
func (*binaryClassGlProgramUniform1uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform1uivEXT(d, obj.(*GlProgramUniform1uivEXT))
}
func (*binaryClassGlProgramUniform1uivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform1uivEXT(d)
}
func (*binaryClassGlProgramUniform1uivEXT) Schema() *schema.Class {
	return schemaGlProgramUniform1uivEXT
}

var schemaGlProgramUniform1uivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform1uivEXT,
	Package: "gles",
	Name:    "GlProgramUniform1uivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2f struct{}

func (*GlProgramUniform2f) Class() binary.Class {
	return (*binaryClassGlProgramUniform2f)(nil)
}
func doEncodeGlProgramUniform2f(e binary.Encoder, o *GlProgramUniform2f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2f(d binary.Decoder, o *GlProgramUniform2f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform2f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2f) ID() binary.ID      { return binaryIDGlProgramUniform2f }
func (*binaryClassGlProgramUniform2f) New() binary.Object { return &GlProgramUniform2f{} }
func (*binaryClassGlProgramUniform2f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2f(e, obj.(*GlProgramUniform2f))
}
func (*binaryClassGlProgramUniform2f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2f{}
	return obj, doDecodeGlProgramUniform2f(d, obj)
}
func (*binaryClassGlProgramUniform2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2f(d, obj.(*GlProgramUniform2f))
}
func (*binaryClassGlProgramUniform2f) Skip(d binary.Decoder) error { return doSkipGlProgramUniform2f(d) }
func (*binaryClassGlProgramUniform2f) Schema() *schema.Class       { return schemaGlProgramUniform2f }

var schemaGlProgramUniform2f = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2f,
	Package: "gles",
	Name:    "GlProgramUniform2f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform2fEXT struct{}

func (*GlProgramUniform2fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fEXT)(nil)
}
func doEncodeGlProgramUniform2fEXT(e binary.Encoder, o *GlProgramUniform2fEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2fEXT(d binary.Decoder, o *GlProgramUniform2fEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform2fEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2fEXT) ID() binary.ID      { return binaryIDGlProgramUniform2fEXT }
func (*binaryClassGlProgramUniform2fEXT) New() binary.Object { return &GlProgramUniform2fEXT{} }
func (*binaryClassGlProgramUniform2fEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2fEXT(e, obj.(*GlProgramUniform2fEXT))
}
func (*binaryClassGlProgramUniform2fEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2fEXT{}
	return obj, doDecodeGlProgramUniform2fEXT(d, obj)
}
func (*binaryClassGlProgramUniform2fEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2fEXT(d, obj.(*GlProgramUniform2fEXT))
}
func (*binaryClassGlProgramUniform2fEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2fEXT(d)
}
func (*binaryClassGlProgramUniform2fEXT) Schema() *schema.Class { return schemaGlProgramUniform2fEXT }

var schemaGlProgramUniform2fEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2fEXT,
	Package: "gles",
	Name:    "GlProgramUniform2fEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform2fv struct{}

func (*GlProgramUniform2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fv)(nil)
}
func doEncodeGlProgramUniform2fv(e binary.Encoder, o *GlProgramUniform2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2fv(d binary.Decoder, o *GlProgramUniform2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2fv) ID() binary.ID      { return binaryIDGlProgramUniform2fv }
func (*binaryClassGlProgramUniform2fv) New() binary.Object { return &GlProgramUniform2fv{} }
func (*binaryClassGlProgramUniform2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2fv(e, obj.(*GlProgramUniform2fv))
}
func (*binaryClassGlProgramUniform2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2fv{}
	return obj, doDecodeGlProgramUniform2fv(d, obj)
}
func (*binaryClassGlProgramUniform2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2fv(d, obj.(*GlProgramUniform2fv))
}
func (*binaryClassGlProgramUniform2fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2fv(d)
}
func (*binaryClassGlProgramUniform2fv) Schema() *schema.Class { return schemaGlProgramUniform2fv }

var schemaGlProgramUniform2fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2fv,
	Package: "gles",
	Name:    "GlProgramUniform2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2fvEXT struct{}

func (*GlProgramUniform2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2fvEXT)(nil)
}
func doEncodeGlProgramUniform2fvEXT(e binary.Encoder, o *GlProgramUniform2fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2fvEXT(d binary.Decoder, o *GlProgramUniform2fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2fvEXT) ID() binary.ID      { return binaryIDGlProgramUniform2fvEXT }
func (*binaryClassGlProgramUniform2fvEXT) New() binary.Object { return &GlProgramUniform2fvEXT{} }
func (*binaryClassGlProgramUniform2fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2fvEXT(e, obj.(*GlProgramUniform2fvEXT))
}
func (*binaryClassGlProgramUniform2fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2fvEXT{}
	return obj, doDecodeGlProgramUniform2fvEXT(d, obj)
}
func (*binaryClassGlProgramUniform2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2fvEXT(d, obj.(*GlProgramUniform2fvEXT))
}
func (*binaryClassGlProgramUniform2fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2fvEXT(d)
}
func (*binaryClassGlProgramUniform2fvEXT) Schema() *schema.Class { return schemaGlProgramUniform2fvEXT }

var schemaGlProgramUniform2fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2fvEXT,
	Package: "gles",
	Name:    "GlProgramUniform2fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2i struct{}

func (*GlProgramUniform2i) Class() binary.Class {
	return (*binaryClassGlProgramUniform2i)(nil)
}
func doEncodeGlProgramUniform2i(e binary.Encoder, o *GlProgramUniform2i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2i(d binary.Decoder, o *GlProgramUniform2i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform2i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2i) ID() binary.ID      { return binaryIDGlProgramUniform2i }
func (*binaryClassGlProgramUniform2i) New() binary.Object { return &GlProgramUniform2i{} }
func (*binaryClassGlProgramUniform2i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2i(e, obj.(*GlProgramUniform2i))
}
func (*binaryClassGlProgramUniform2i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2i{}
	return obj, doDecodeGlProgramUniform2i(d, obj)
}
func (*binaryClassGlProgramUniform2i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2i(d, obj.(*GlProgramUniform2i))
}
func (*binaryClassGlProgramUniform2i) Skip(d binary.Decoder) error { return doSkipGlProgramUniform2i(d) }
func (*binaryClassGlProgramUniform2i) Schema() *schema.Class       { return schemaGlProgramUniform2i }

var schemaGlProgramUniform2i = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2i,
	Package: "gles",
	Name:    "GlProgramUniform2i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform2iEXT struct{}

func (*GlProgramUniform2iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2iEXT)(nil)
}
func doEncodeGlProgramUniform2iEXT(e binary.Encoder, o *GlProgramUniform2iEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2iEXT(d binary.Decoder, o *GlProgramUniform2iEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform2iEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2iEXT) ID() binary.ID      { return binaryIDGlProgramUniform2iEXT }
func (*binaryClassGlProgramUniform2iEXT) New() binary.Object { return &GlProgramUniform2iEXT{} }
func (*binaryClassGlProgramUniform2iEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2iEXT(e, obj.(*GlProgramUniform2iEXT))
}
func (*binaryClassGlProgramUniform2iEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2iEXT{}
	return obj, doDecodeGlProgramUniform2iEXT(d, obj)
}
func (*binaryClassGlProgramUniform2iEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2iEXT(d, obj.(*GlProgramUniform2iEXT))
}
func (*binaryClassGlProgramUniform2iEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2iEXT(d)
}
func (*binaryClassGlProgramUniform2iEXT) Schema() *schema.Class { return schemaGlProgramUniform2iEXT }

var schemaGlProgramUniform2iEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2iEXT,
	Package: "gles",
	Name:    "GlProgramUniform2iEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform2iv struct{}

func (*GlProgramUniform2iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2iv)(nil)
}
func doEncodeGlProgramUniform2iv(e binary.Encoder, o *GlProgramUniform2iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2iv(d binary.Decoder, o *GlProgramUniform2iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2iv) ID() binary.ID      { return binaryIDGlProgramUniform2iv }
func (*binaryClassGlProgramUniform2iv) New() binary.Object { return &GlProgramUniform2iv{} }
func (*binaryClassGlProgramUniform2iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2iv(e, obj.(*GlProgramUniform2iv))
}
func (*binaryClassGlProgramUniform2iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2iv{}
	return obj, doDecodeGlProgramUniform2iv(d, obj)
}
func (*binaryClassGlProgramUniform2iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2iv(d, obj.(*GlProgramUniform2iv))
}
func (*binaryClassGlProgramUniform2iv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2iv(d)
}
func (*binaryClassGlProgramUniform2iv) Schema() *schema.Class { return schemaGlProgramUniform2iv }

var schemaGlProgramUniform2iv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2iv,
	Package: "gles",
	Name:    "GlProgramUniform2iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2ivEXT struct{}

func (*GlProgramUniform2ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2ivEXT)(nil)
}
func doEncodeGlProgramUniform2ivEXT(e binary.Encoder, o *GlProgramUniform2ivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2ivEXT(d binary.Decoder, o *GlProgramUniform2ivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2ivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2ivEXT) ID() binary.ID      { return binaryIDGlProgramUniform2ivEXT }
func (*binaryClassGlProgramUniform2ivEXT) New() binary.Object { return &GlProgramUniform2ivEXT{} }
func (*binaryClassGlProgramUniform2ivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2ivEXT(e, obj.(*GlProgramUniform2ivEXT))
}
func (*binaryClassGlProgramUniform2ivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2ivEXT{}
	return obj, doDecodeGlProgramUniform2ivEXT(d, obj)
}
func (*binaryClassGlProgramUniform2ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2ivEXT(d, obj.(*GlProgramUniform2ivEXT))
}
func (*binaryClassGlProgramUniform2ivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2ivEXT(d)
}
func (*binaryClassGlProgramUniform2ivEXT) Schema() *schema.Class { return schemaGlProgramUniform2ivEXT }

var schemaGlProgramUniform2ivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2ivEXT,
	Package: "gles",
	Name:    "GlProgramUniform2ivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2ui struct{}

func (*GlProgramUniform2ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform2ui)(nil)
}
func doEncodeGlProgramUniform2ui(e binary.Encoder, o *GlProgramUniform2ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2ui(d binary.Decoder, o *GlProgramUniform2ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform2ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2ui) ID() binary.ID      { return binaryIDGlProgramUniform2ui }
func (*binaryClassGlProgramUniform2ui) New() binary.Object { return &GlProgramUniform2ui{} }
func (*binaryClassGlProgramUniform2ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2ui(e, obj.(*GlProgramUniform2ui))
}
func (*binaryClassGlProgramUniform2ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2ui{}
	return obj, doDecodeGlProgramUniform2ui(d, obj)
}
func (*binaryClassGlProgramUniform2ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2ui(d, obj.(*GlProgramUniform2ui))
}
func (*binaryClassGlProgramUniform2ui) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2ui(d)
}
func (*binaryClassGlProgramUniform2ui) Schema() *schema.Class { return schemaGlProgramUniform2ui }

var schemaGlProgramUniform2ui = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2ui,
	Package: "gles",
	Name:    "GlProgramUniform2ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform2uiEXT struct{}

func (*GlProgramUniform2uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uiEXT)(nil)
}
func doEncodeGlProgramUniform2uiEXT(e binary.Encoder, o *GlProgramUniform2uiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2uiEXT(d binary.Decoder, o *GlProgramUniform2uiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform2uiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2uiEXT) ID() binary.ID      { return binaryIDGlProgramUniform2uiEXT }
func (*binaryClassGlProgramUniform2uiEXT) New() binary.Object { return &GlProgramUniform2uiEXT{} }
func (*binaryClassGlProgramUniform2uiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2uiEXT(e, obj.(*GlProgramUniform2uiEXT))
}
func (*binaryClassGlProgramUniform2uiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2uiEXT{}
	return obj, doDecodeGlProgramUniform2uiEXT(d, obj)
}
func (*binaryClassGlProgramUniform2uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2uiEXT(d, obj.(*GlProgramUniform2uiEXT))
}
func (*binaryClassGlProgramUniform2uiEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2uiEXT(d)
}
func (*binaryClassGlProgramUniform2uiEXT) Schema() *schema.Class { return schemaGlProgramUniform2uiEXT }

var schemaGlProgramUniform2uiEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2uiEXT,
	Package: "gles",
	Name:    "GlProgramUniform2uiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform2uiv struct{}

func (*GlProgramUniform2uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uiv)(nil)
}
func doEncodeGlProgramUniform2uiv(e binary.Encoder, o *GlProgramUniform2uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2uiv(d binary.Decoder, o *GlProgramUniform2uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2uiv) ID() binary.ID      { return binaryIDGlProgramUniform2uiv }
func (*binaryClassGlProgramUniform2uiv) New() binary.Object { return &GlProgramUniform2uiv{} }
func (*binaryClassGlProgramUniform2uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2uiv(e, obj.(*GlProgramUniform2uiv))
}
func (*binaryClassGlProgramUniform2uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2uiv{}
	return obj, doDecodeGlProgramUniform2uiv(d, obj)
}
func (*binaryClassGlProgramUniform2uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2uiv(d, obj.(*GlProgramUniform2uiv))
}
func (*binaryClassGlProgramUniform2uiv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2uiv(d)
}
func (*binaryClassGlProgramUniform2uiv) Schema() *schema.Class { return schemaGlProgramUniform2uiv }

var schemaGlProgramUniform2uiv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2uiv,
	Package: "gles",
	Name:    "GlProgramUniform2uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform2uivEXT struct{}

func (*GlProgramUniform2uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform2uivEXT)(nil)
}
func doEncodeGlProgramUniform2uivEXT(e binary.Encoder, o *GlProgramUniform2uivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform2uivEXT(d binary.Decoder, o *GlProgramUniform2uivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform2uivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform2uivEXT) ID() binary.ID      { return binaryIDGlProgramUniform2uivEXT }
func (*binaryClassGlProgramUniform2uivEXT) New() binary.Object { return &GlProgramUniform2uivEXT{} }
func (*binaryClassGlProgramUniform2uivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform2uivEXT(e, obj.(*GlProgramUniform2uivEXT))
}
func (*binaryClassGlProgramUniform2uivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform2uivEXT{}
	return obj, doDecodeGlProgramUniform2uivEXT(d, obj)
}
func (*binaryClassGlProgramUniform2uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform2uivEXT(d, obj.(*GlProgramUniform2uivEXT))
}
func (*binaryClassGlProgramUniform2uivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform2uivEXT(d)
}
func (*binaryClassGlProgramUniform2uivEXT) Schema() *schema.Class {
	return schemaGlProgramUniform2uivEXT
}

var schemaGlProgramUniform2uivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform2uivEXT,
	Package: "gles",
	Name:    "GlProgramUniform2uivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3f struct{}

func (*GlProgramUniform3f) Class() binary.Class {
	return (*binaryClassGlProgramUniform3f)(nil)
}
func doEncodeGlProgramUniform3f(e binary.Encoder, o *GlProgramUniform3f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3f(d binary.Decoder, o *GlProgramUniform3f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V2 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform3f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3f) ID() binary.ID      { return binaryIDGlProgramUniform3f }
func (*binaryClassGlProgramUniform3f) New() binary.Object { return &GlProgramUniform3f{} }
func (*binaryClassGlProgramUniform3f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3f(e, obj.(*GlProgramUniform3f))
}
func (*binaryClassGlProgramUniform3f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3f{}
	return obj, doDecodeGlProgramUniform3f(d, obj)
}
func (*binaryClassGlProgramUniform3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3f(d, obj.(*GlProgramUniform3f))
}
func (*binaryClassGlProgramUniform3f) Skip(d binary.Decoder) error { return doSkipGlProgramUniform3f(d) }
func (*binaryClassGlProgramUniform3f) Schema() *schema.Class       { return schemaGlProgramUniform3f }

var schemaGlProgramUniform3f = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3f,
	Package: "gles",
	Name:    "GlProgramUniform3f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform3fEXT struct{}

func (*GlProgramUniform3fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fEXT)(nil)
}
func doEncodeGlProgramUniform3fEXT(e binary.Encoder, o *GlProgramUniform3fEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3fEXT(d binary.Decoder, o *GlProgramUniform3fEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V2 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform3fEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3fEXT) ID() binary.ID      { return binaryIDGlProgramUniform3fEXT }
func (*binaryClassGlProgramUniform3fEXT) New() binary.Object { return &GlProgramUniform3fEXT{} }
func (*binaryClassGlProgramUniform3fEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3fEXT(e, obj.(*GlProgramUniform3fEXT))
}
func (*binaryClassGlProgramUniform3fEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3fEXT{}
	return obj, doDecodeGlProgramUniform3fEXT(d, obj)
}
func (*binaryClassGlProgramUniform3fEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3fEXT(d, obj.(*GlProgramUniform3fEXT))
}
func (*binaryClassGlProgramUniform3fEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3fEXT(d)
}
func (*binaryClassGlProgramUniform3fEXT) Schema() *schema.Class { return schemaGlProgramUniform3fEXT }

var schemaGlProgramUniform3fEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3fEXT,
	Package: "gles",
	Name:    "GlProgramUniform3fEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform3fv struct{}

func (*GlProgramUniform3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fv)(nil)
}
func doEncodeGlProgramUniform3fv(e binary.Encoder, o *GlProgramUniform3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3fv(d binary.Decoder, o *GlProgramUniform3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3fv) ID() binary.ID      { return binaryIDGlProgramUniform3fv }
func (*binaryClassGlProgramUniform3fv) New() binary.Object { return &GlProgramUniform3fv{} }
func (*binaryClassGlProgramUniform3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3fv(e, obj.(*GlProgramUniform3fv))
}
func (*binaryClassGlProgramUniform3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3fv{}
	return obj, doDecodeGlProgramUniform3fv(d, obj)
}
func (*binaryClassGlProgramUniform3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3fv(d, obj.(*GlProgramUniform3fv))
}
func (*binaryClassGlProgramUniform3fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3fv(d)
}
func (*binaryClassGlProgramUniform3fv) Schema() *schema.Class { return schemaGlProgramUniform3fv }

var schemaGlProgramUniform3fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3fv,
	Package: "gles",
	Name:    "GlProgramUniform3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3fvEXT struct{}

func (*GlProgramUniform3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3fvEXT)(nil)
}
func doEncodeGlProgramUniform3fvEXT(e binary.Encoder, o *GlProgramUniform3fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3fvEXT(d binary.Decoder, o *GlProgramUniform3fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3fvEXT) ID() binary.ID      { return binaryIDGlProgramUniform3fvEXT }
func (*binaryClassGlProgramUniform3fvEXT) New() binary.Object { return &GlProgramUniform3fvEXT{} }
func (*binaryClassGlProgramUniform3fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3fvEXT(e, obj.(*GlProgramUniform3fvEXT))
}
func (*binaryClassGlProgramUniform3fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3fvEXT{}
	return obj, doDecodeGlProgramUniform3fvEXT(d, obj)
}
func (*binaryClassGlProgramUniform3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3fvEXT(d, obj.(*GlProgramUniform3fvEXT))
}
func (*binaryClassGlProgramUniform3fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3fvEXT(d)
}
func (*binaryClassGlProgramUniform3fvEXT) Schema() *schema.Class { return schemaGlProgramUniform3fvEXT }

var schemaGlProgramUniform3fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3fvEXT,
	Package: "gles",
	Name:    "GlProgramUniform3fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3i struct{}

func (*GlProgramUniform3i) Class() binary.Class {
	return (*binaryClassGlProgramUniform3i)(nil)
}
func doEncodeGlProgramUniform3i(e binary.Encoder, o *GlProgramUniform3i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3i(d binary.Decoder, o *GlProgramUniform3i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V2 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform3i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3i) ID() binary.ID      { return binaryIDGlProgramUniform3i }
func (*binaryClassGlProgramUniform3i) New() binary.Object { return &GlProgramUniform3i{} }
func (*binaryClassGlProgramUniform3i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3i(e, obj.(*GlProgramUniform3i))
}
func (*binaryClassGlProgramUniform3i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3i{}
	return obj, doDecodeGlProgramUniform3i(d, obj)
}
func (*binaryClassGlProgramUniform3i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3i(d, obj.(*GlProgramUniform3i))
}
func (*binaryClassGlProgramUniform3i) Skip(d binary.Decoder) error { return doSkipGlProgramUniform3i(d) }
func (*binaryClassGlProgramUniform3i) Schema() *schema.Class       { return schemaGlProgramUniform3i }

var schemaGlProgramUniform3i = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3i,
	Package: "gles",
	Name:    "GlProgramUniform3i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform3iEXT struct{}

func (*GlProgramUniform3iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3iEXT)(nil)
}
func doEncodeGlProgramUniform3iEXT(e binary.Encoder, o *GlProgramUniform3iEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3iEXT(d binary.Decoder, o *GlProgramUniform3iEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V2 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform3iEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3iEXT) ID() binary.ID      { return binaryIDGlProgramUniform3iEXT }
func (*binaryClassGlProgramUniform3iEXT) New() binary.Object { return &GlProgramUniform3iEXT{} }
func (*binaryClassGlProgramUniform3iEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3iEXT(e, obj.(*GlProgramUniform3iEXT))
}
func (*binaryClassGlProgramUniform3iEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3iEXT{}
	return obj, doDecodeGlProgramUniform3iEXT(d, obj)
}
func (*binaryClassGlProgramUniform3iEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3iEXT(d, obj.(*GlProgramUniform3iEXT))
}
func (*binaryClassGlProgramUniform3iEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3iEXT(d)
}
func (*binaryClassGlProgramUniform3iEXT) Schema() *schema.Class { return schemaGlProgramUniform3iEXT }

var schemaGlProgramUniform3iEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3iEXT,
	Package: "gles",
	Name:    "GlProgramUniform3iEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform3iv struct{}

func (*GlProgramUniform3iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3iv)(nil)
}
func doEncodeGlProgramUniform3iv(e binary.Encoder, o *GlProgramUniform3iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3iv(d binary.Decoder, o *GlProgramUniform3iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3iv) ID() binary.ID      { return binaryIDGlProgramUniform3iv }
func (*binaryClassGlProgramUniform3iv) New() binary.Object { return &GlProgramUniform3iv{} }
func (*binaryClassGlProgramUniform3iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3iv(e, obj.(*GlProgramUniform3iv))
}
func (*binaryClassGlProgramUniform3iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3iv{}
	return obj, doDecodeGlProgramUniform3iv(d, obj)
}
func (*binaryClassGlProgramUniform3iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3iv(d, obj.(*GlProgramUniform3iv))
}
func (*binaryClassGlProgramUniform3iv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3iv(d)
}
func (*binaryClassGlProgramUniform3iv) Schema() *schema.Class { return schemaGlProgramUniform3iv }

var schemaGlProgramUniform3iv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3iv,
	Package: "gles",
	Name:    "GlProgramUniform3iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3ivEXT struct{}

func (*GlProgramUniform3ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3ivEXT)(nil)
}
func doEncodeGlProgramUniform3ivEXT(e binary.Encoder, o *GlProgramUniform3ivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3ivEXT(d binary.Decoder, o *GlProgramUniform3ivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3ivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3ivEXT) ID() binary.ID      { return binaryIDGlProgramUniform3ivEXT }
func (*binaryClassGlProgramUniform3ivEXT) New() binary.Object { return &GlProgramUniform3ivEXT{} }
func (*binaryClassGlProgramUniform3ivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3ivEXT(e, obj.(*GlProgramUniform3ivEXT))
}
func (*binaryClassGlProgramUniform3ivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3ivEXT{}
	return obj, doDecodeGlProgramUniform3ivEXT(d, obj)
}
func (*binaryClassGlProgramUniform3ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3ivEXT(d, obj.(*GlProgramUniform3ivEXT))
}
func (*binaryClassGlProgramUniform3ivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3ivEXT(d)
}
func (*binaryClassGlProgramUniform3ivEXT) Schema() *schema.Class { return schemaGlProgramUniform3ivEXT }

var schemaGlProgramUniform3ivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3ivEXT,
	Package: "gles",
	Name:    "GlProgramUniform3ivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3ui struct{}

func (*GlProgramUniform3ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform3ui)(nil)
}
func doEncodeGlProgramUniform3ui(e binary.Encoder, o *GlProgramUniform3ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3ui(d binary.Decoder, o *GlProgramUniform3ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform3ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3ui) ID() binary.ID      { return binaryIDGlProgramUniform3ui }
func (*binaryClassGlProgramUniform3ui) New() binary.Object { return &GlProgramUniform3ui{} }
func (*binaryClassGlProgramUniform3ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3ui(e, obj.(*GlProgramUniform3ui))
}
func (*binaryClassGlProgramUniform3ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3ui{}
	return obj, doDecodeGlProgramUniform3ui(d, obj)
}
func (*binaryClassGlProgramUniform3ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3ui(d, obj.(*GlProgramUniform3ui))
}
func (*binaryClassGlProgramUniform3ui) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3ui(d)
}
func (*binaryClassGlProgramUniform3ui) Schema() *schema.Class { return schemaGlProgramUniform3ui }

var schemaGlProgramUniform3ui = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3ui,
	Package: "gles",
	Name:    "GlProgramUniform3ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform3uiEXT struct{}

func (*GlProgramUniform3uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uiEXT)(nil)
}
func doEncodeGlProgramUniform3uiEXT(e binary.Encoder, o *GlProgramUniform3uiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3uiEXT(d binary.Decoder, o *GlProgramUniform3uiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform3uiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3uiEXT) ID() binary.ID      { return binaryIDGlProgramUniform3uiEXT }
func (*binaryClassGlProgramUniform3uiEXT) New() binary.Object { return &GlProgramUniform3uiEXT{} }
func (*binaryClassGlProgramUniform3uiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3uiEXT(e, obj.(*GlProgramUniform3uiEXT))
}
func (*binaryClassGlProgramUniform3uiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3uiEXT{}
	return obj, doDecodeGlProgramUniform3uiEXT(d, obj)
}
func (*binaryClassGlProgramUniform3uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3uiEXT(d, obj.(*GlProgramUniform3uiEXT))
}
func (*binaryClassGlProgramUniform3uiEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3uiEXT(d)
}
func (*binaryClassGlProgramUniform3uiEXT) Schema() *schema.Class { return schemaGlProgramUniform3uiEXT }

var schemaGlProgramUniform3uiEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3uiEXT,
	Package: "gles",
	Name:    "GlProgramUniform3uiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform3uiv struct{}

func (*GlProgramUniform3uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uiv)(nil)
}
func doEncodeGlProgramUniform3uiv(e binary.Encoder, o *GlProgramUniform3uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3uiv(d binary.Decoder, o *GlProgramUniform3uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3uiv) ID() binary.ID      { return binaryIDGlProgramUniform3uiv }
func (*binaryClassGlProgramUniform3uiv) New() binary.Object { return &GlProgramUniform3uiv{} }
func (*binaryClassGlProgramUniform3uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3uiv(e, obj.(*GlProgramUniform3uiv))
}
func (*binaryClassGlProgramUniform3uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3uiv{}
	return obj, doDecodeGlProgramUniform3uiv(d, obj)
}
func (*binaryClassGlProgramUniform3uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3uiv(d, obj.(*GlProgramUniform3uiv))
}
func (*binaryClassGlProgramUniform3uiv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3uiv(d)
}
func (*binaryClassGlProgramUniform3uiv) Schema() *schema.Class { return schemaGlProgramUniform3uiv }

var schemaGlProgramUniform3uiv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3uiv,
	Package: "gles",
	Name:    "GlProgramUniform3uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform3uivEXT struct{}

func (*GlProgramUniform3uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform3uivEXT)(nil)
}
func doEncodeGlProgramUniform3uivEXT(e binary.Encoder, o *GlProgramUniform3uivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform3uivEXT(d binary.Decoder, o *GlProgramUniform3uivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform3uivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform3uivEXT) ID() binary.ID      { return binaryIDGlProgramUniform3uivEXT }
func (*binaryClassGlProgramUniform3uivEXT) New() binary.Object { return &GlProgramUniform3uivEXT{} }
func (*binaryClassGlProgramUniform3uivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform3uivEXT(e, obj.(*GlProgramUniform3uivEXT))
}
func (*binaryClassGlProgramUniform3uivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform3uivEXT{}
	return obj, doDecodeGlProgramUniform3uivEXT(d, obj)
}
func (*binaryClassGlProgramUniform3uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform3uivEXT(d, obj.(*GlProgramUniform3uivEXT))
}
func (*binaryClassGlProgramUniform3uivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform3uivEXT(d)
}
func (*binaryClassGlProgramUniform3uivEXT) Schema() *schema.Class {
	return schemaGlProgramUniform3uivEXT
}

var schemaGlProgramUniform3uivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform3uivEXT,
	Package: "gles",
	Name:    "GlProgramUniform3uivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4f struct{}

func (*GlProgramUniform4f) Class() binary.Class {
	return (*binaryClassGlProgramUniform4f)(nil)
}
func doEncodeGlProgramUniform4f(e binary.Encoder, o *GlProgramUniform4f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V2)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4f(d binary.Decoder, o *GlProgramUniform4f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V2 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V3 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform4f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4f) ID() binary.ID      { return binaryIDGlProgramUniform4f }
func (*binaryClassGlProgramUniform4f) New() binary.Object { return &GlProgramUniform4f{} }
func (*binaryClassGlProgramUniform4f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4f(e, obj.(*GlProgramUniform4f))
}
func (*binaryClassGlProgramUniform4f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4f{}
	return obj, doDecodeGlProgramUniform4f(d, obj)
}
func (*binaryClassGlProgramUniform4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4f(d, obj.(*GlProgramUniform4f))
}
func (*binaryClassGlProgramUniform4f) Skip(d binary.Decoder) error { return doSkipGlProgramUniform4f(d) }
func (*binaryClassGlProgramUniform4f) Schema() *schema.Class       { return schemaGlProgramUniform4f }

var schemaGlProgramUniform4f = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4f,
	Package: "gles",
	Name:    "GlProgramUniform4f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform4fEXT struct{}

func (*GlProgramUniform4fEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fEXT)(nil)
}
func doEncodeGlProgramUniform4fEXT(e binary.Encoder, o *GlProgramUniform4fEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V2)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4fEXT(d binary.Decoder, o *GlProgramUniform4fEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V2 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.V3 = GLfloat(obj)
	}
	return nil
}
func doSkipGlProgramUniform4fEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4fEXT) ID() binary.ID      { return binaryIDGlProgramUniform4fEXT }
func (*binaryClassGlProgramUniform4fEXT) New() binary.Object { return &GlProgramUniform4fEXT{} }
func (*binaryClassGlProgramUniform4fEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4fEXT(e, obj.(*GlProgramUniform4fEXT))
}
func (*binaryClassGlProgramUniform4fEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4fEXT{}
	return obj, doDecodeGlProgramUniform4fEXT(d, obj)
}
func (*binaryClassGlProgramUniform4fEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4fEXT(d, obj.(*GlProgramUniform4fEXT))
}
func (*binaryClassGlProgramUniform4fEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4fEXT(d)
}
func (*binaryClassGlProgramUniform4fEXT) Schema() *schema.Class { return schemaGlProgramUniform4fEXT }

var schemaGlProgramUniform4fEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4fEXT,
	Package: "gles",
	Name:    "GlProgramUniform4fEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlProgramUniform4fv struct{}

func (*GlProgramUniform4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fv)(nil)
}
func doEncodeGlProgramUniform4fv(e binary.Encoder, o *GlProgramUniform4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4fv(d binary.Decoder, o *GlProgramUniform4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4fv) ID() binary.ID      { return binaryIDGlProgramUniform4fv }
func (*binaryClassGlProgramUniform4fv) New() binary.Object { return &GlProgramUniform4fv{} }
func (*binaryClassGlProgramUniform4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4fv(e, obj.(*GlProgramUniform4fv))
}
func (*binaryClassGlProgramUniform4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4fv{}
	return obj, doDecodeGlProgramUniform4fv(d, obj)
}
func (*binaryClassGlProgramUniform4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4fv(d, obj.(*GlProgramUniform4fv))
}
func (*binaryClassGlProgramUniform4fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4fv(d)
}
func (*binaryClassGlProgramUniform4fv) Schema() *schema.Class { return schemaGlProgramUniform4fv }

var schemaGlProgramUniform4fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4fv,
	Package: "gles",
	Name:    "GlProgramUniform4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4fvEXT struct{}

func (*GlProgramUniform4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4fvEXT)(nil)
}
func doEncodeGlProgramUniform4fvEXT(e binary.Encoder, o *GlProgramUniform4fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4fvEXT(d binary.Decoder, o *GlProgramUniform4fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4fvEXT) ID() binary.ID      { return binaryIDGlProgramUniform4fvEXT }
func (*binaryClassGlProgramUniform4fvEXT) New() binary.Object { return &GlProgramUniform4fvEXT{} }
func (*binaryClassGlProgramUniform4fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4fvEXT(e, obj.(*GlProgramUniform4fvEXT))
}
func (*binaryClassGlProgramUniform4fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4fvEXT{}
	return obj, doDecodeGlProgramUniform4fvEXT(d, obj)
}
func (*binaryClassGlProgramUniform4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4fvEXT(d, obj.(*GlProgramUniform4fvEXT))
}
func (*binaryClassGlProgramUniform4fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4fvEXT(d)
}
func (*binaryClassGlProgramUniform4fvEXT) Schema() *schema.Class { return schemaGlProgramUniform4fvEXT }

var schemaGlProgramUniform4fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4fvEXT,
	Package: "gles",
	Name:    "GlProgramUniform4fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4i struct{}

func (*GlProgramUniform4i) Class() binary.Class {
	return (*binaryClassGlProgramUniform4i)(nil)
}
func doEncodeGlProgramUniform4i(e binary.Encoder, o *GlProgramUniform4i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V2)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4i(d binary.Decoder, o *GlProgramUniform4i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V2 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V3 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform4i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4i) ID() binary.ID      { return binaryIDGlProgramUniform4i }
func (*binaryClassGlProgramUniform4i) New() binary.Object { return &GlProgramUniform4i{} }
func (*binaryClassGlProgramUniform4i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4i(e, obj.(*GlProgramUniform4i))
}
func (*binaryClassGlProgramUniform4i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4i{}
	return obj, doDecodeGlProgramUniform4i(d, obj)
}
func (*binaryClassGlProgramUniform4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4i(d, obj.(*GlProgramUniform4i))
}
func (*binaryClassGlProgramUniform4i) Skip(d binary.Decoder) error { return doSkipGlProgramUniform4i(d) }
func (*binaryClassGlProgramUniform4i) Schema() *schema.Class       { return schemaGlProgramUniform4i }

var schemaGlProgramUniform4i = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4i,
	Package: "gles",
	Name:    "GlProgramUniform4i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform4iEXT struct{}

func (*GlProgramUniform4iEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4iEXT)(nil)
}
func doEncodeGlProgramUniform4iEXT(e binary.Encoder, o *GlProgramUniform4iEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V2)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4iEXT(d binary.Decoder, o *GlProgramUniform4iEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V2 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.V3 = GLint(obj)
	}
	return nil
}
func doSkipGlProgramUniform4iEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4iEXT) ID() binary.ID      { return binaryIDGlProgramUniform4iEXT }
func (*binaryClassGlProgramUniform4iEXT) New() binary.Object { return &GlProgramUniform4iEXT{} }
func (*binaryClassGlProgramUniform4iEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4iEXT(e, obj.(*GlProgramUniform4iEXT))
}
func (*binaryClassGlProgramUniform4iEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4iEXT{}
	return obj, doDecodeGlProgramUniform4iEXT(d, obj)
}
func (*binaryClassGlProgramUniform4iEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4iEXT(d, obj.(*GlProgramUniform4iEXT))
}
func (*binaryClassGlProgramUniform4iEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4iEXT(d)
}
func (*binaryClassGlProgramUniform4iEXT) Schema() *schema.Class { return schemaGlProgramUniform4iEXT }

var schemaGlProgramUniform4iEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4iEXT,
	Package: "gles",
	Name:    "GlProgramUniform4iEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlProgramUniform4iv struct{}

func (*GlProgramUniform4iv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4iv)(nil)
}
func doEncodeGlProgramUniform4iv(e binary.Encoder, o *GlProgramUniform4iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4iv(d binary.Decoder, o *GlProgramUniform4iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4iv) ID() binary.ID      { return binaryIDGlProgramUniform4iv }
func (*binaryClassGlProgramUniform4iv) New() binary.Object { return &GlProgramUniform4iv{} }
func (*binaryClassGlProgramUniform4iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4iv(e, obj.(*GlProgramUniform4iv))
}
func (*binaryClassGlProgramUniform4iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4iv{}
	return obj, doDecodeGlProgramUniform4iv(d, obj)
}
func (*binaryClassGlProgramUniform4iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4iv(d, obj.(*GlProgramUniform4iv))
}
func (*binaryClassGlProgramUniform4iv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4iv(d)
}
func (*binaryClassGlProgramUniform4iv) Schema() *schema.Class { return schemaGlProgramUniform4iv }

var schemaGlProgramUniform4iv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4iv,
	Package: "gles",
	Name:    "GlProgramUniform4iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4ivEXT struct{}

func (*GlProgramUniform4ivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4ivEXT)(nil)
}
func doEncodeGlProgramUniform4ivEXT(e binary.Encoder, o *GlProgramUniform4ivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4ivEXT(d binary.Decoder, o *GlProgramUniform4ivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4ivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4ivEXT) ID() binary.ID      { return binaryIDGlProgramUniform4ivEXT }
func (*binaryClassGlProgramUniform4ivEXT) New() binary.Object { return &GlProgramUniform4ivEXT{} }
func (*binaryClassGlProgramUniform4ivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4ivEXT(e, obj.(*GlProgramUniform4ivEXT))
}
func (*binaryClassGlProgramUniform4ivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4ivEXT{}
	return obj, doDecodeGlProgramUniform4ivEXT(d, obj)
}
func (*binaryClassGlProgramUniform4ivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4ivEXT(d, obj.(*GlProgramUniform4ivEXT))
}
func (*binaryClassGlProgramUniform4ivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4ivEXT(d)
}
func (*binaryClassGlProgramUniform4ivEXT) Schema() *schema.Class { return schemaGlProgramUniform4ivEXT }

var schemaGlProgramUniform4ivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4ivEXT,
	Package: "gles",
	Name:    "GlProgramUniform4ivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4ui struct{}

func (*GlProgramUniform4ui) Class() binary.Class {
	return (*binaryClassGlProgramUniform4ui)(nil)
}
func doEncodeGlProgramUniform4ui(e binary.Encoder, o *GlProgramUniform4ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4ui(d binary.Decoder, o *GlProgramUniform4ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V3 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform4ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4ui) ID() binary.ID      { return binaryIDGlProgramUniform4ui }
func (*binaryClassGlProgramUniform4ui) New() binary.Object { return &GlProgramUniform4ui{} }
func (*binaryClassGlProgramUniform4ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4ui(e, obj.(*GlProgramUniform4ui))
}
func (*binaryClassGlProgramUniform4ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4ui{}
	return obj, doDecodeGlProgramUniform4ui(d, obj)
}
func (*binaryClassGlProgramUniform4ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4ui(d, obj.(*GlProgramUniform4ui))
}
func (*binaryClassGlProgramUniform4ui) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4ui(d)
}
func (*binaryClassGlProgramUniform4ui) Schema() *schema.Class { return schemaGlProgramUniform4ui }

var schemaGlProgramUniform4ui = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4ui,
	Package: "gles",
	Name:    "GlProgramUniform4ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform4uiEXT struct{}

func (*GlProgramUniform4uiEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uiEXT)(nil)
}
func doEncodeGlProgramUniform4uiEXT(e binary.Encoder, o *GlProgramUniform4uiEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4uiEXT(d binary.Decoder, o *GlProgramUniform4uiEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V3 = GLuint(obj)
	}
	return nil
}
func doSkipGlProgramUniform4uiEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4uiEXT) ID() binary.ID      { return binaryIDGlProgramUniform4uiEXT }
func (*binaryClassGlProgramUniform4uiEXT) New() binary.Object { return &GlProgramUniform4uiEXT{} }
func (*binaryClassGlProgramUniform4uiEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4uiEXT(e, obj.(*GlProgramUniform4uiEXT))
}
func (*binaryClassGlProgramUniform4uiEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4uiEXT{}
	return obj, doDecodeGlProgramUniform4uiEXT(d, obj)
}
func (*binaryClassGlProgramUniform4uiEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4uiEXT(d, obj.(*GlProgramUniform4uiEXT))
}
func (*binaryClassGlProgramUniform4uiEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4uiEXT(d)
}
func (*binaryClassGlProgramUniform4uiEXT) Schema() *schema.Class { return schemaGlProgramUniform4uiEXT }

var schemaGlProgramUniform4uiEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4uiEXT,
	Package: "gles",
	Name:    "GlProgramUniform4uiEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlProgramUniform4uiv struct{}

func (*GlProgramUniform4uiv) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uiv)(nil)
}
func doEncodeGlProgramUniform4uiv(e binary.Encoder, o *GlProgramUniform4uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4uiv(d binary.Decoder, o *GlProgramUniform4uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4uiv) ID() binary.ID      { return binaryIDGlProgramUniform4uiv }
func (*binaryClassGlProgramUniform4uiv) New() binary.Object { return &GlProgramUniform4uiv{} }
func (*binaryClassGlProgramUniform4uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4uiv(e, obj.(*GlProgramUniform4uiv))
}
func (*binaryClassGlProgramUniform4uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4uiv{}
	return obj, doDecodeGlProgramUniform4uiv(d, obj)
}
func (*binaryClassGlProgramUniform4uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4uiv(d, obj.(*GlProgramUniform4uiv))
}
func (*binaryClassGlProgramUniform4uiv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4uiv(d)
}
func (*binaryClassGlProgramUniform4uiv) Schema() *schema.Class { return schemaGlProgramUniform4uiv }

var schemaGlProgramUniform4uiv = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4uiv,
	Package: "gles",
	Name:    "GlProgramUniform4uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniform4uivEXT struct{}

func (*GlProgramUniform4uivEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniform4uivEXT)(nil)
}
func doEncodeGlProgramUniform4uivEXT(e binary.Encoder, o *GlProgramUniform4uivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniform4uivEXT(d binary.Decoder, o *GlProgramUniform4uivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniform4uivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniform4uivEXT) ID() binary.ID      { return binaryIDGlProgramUniform4uivEXT }
func (*binaryClassGlProgramUniform4uivEXT) New() binary.Object { return &GlProgramUniform4uivEXT{} }
func (*binaryClassGlProgramUniform4uivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniform4uivEXT(e, obj.(*GlProgramUniform4uivEXT))
}
func (*binaryClassGlProgramUniform4uivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniform4uivEXT{}
	return obj, doDecodeGlProgramUniform4uivEXT(d, obj)
}
func (*binaryClassGlProgramUniform4uivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniform4uivEXT(d, obj.(*GlProgramUniform4uivEXT))
}
func (*binaryClassGlProgramUniform4uivEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniform4uivEXT(d)
}
func (*binaryClassGlProgramUniform4uivEXT) Schema() *schema.Class {
	return schemaGlProgramUniform4uivEXT
}

var schemaGlProgramUniform4uivEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniform4uivEXT,
	Package: "gles",
	Name:    "GlProgramUniform4uivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformHandleui64NV struct{}

func (*GlProgramUniformHandleui64NV) Class() binary.Class {
	return (*binaryClassGlProgramUniformHandleui64NV)(nil)
}
func doEncodeGlProgramUniformHandleui64NV(e binary.Encoder, o *GlProgramUniformHandleui64NV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformHandleui64NV(d binary.Decoder, o *GlProgramUniformHandleui64NV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Value = GLuint64(obj)
	}
	return nil
}
func doSkipGlProgramUniformHandleui64NV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformHandleui64NV) ID() binary.ID {
	return binaryIDGlProgramUniformHandleui64NV
}
func (*binaryClassGlProgramUniformHandleui64NV) New() binary.Object {
	return &GlProgramUniformHandleui64NV{}
}
func (*binaryClassGlProgramUniformHandleui64NV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformHandleui64NV(e, obj.(*GlProgramUniformHandleui64NV))
}
func (*binaryClassGlProgramUniformHandleui64NV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformHandleui64NV{}
	return obj, doDecodeGlProgramUniformHandleui64NV(d, obj)
}
func (*binaryClassGlProgramUniformHandleui64NV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformHandleui64NV(d, obj.(*GlProgramUniformHandleui64NV))
}
func (*binaryClassGlProgramUniformHandleui64NV) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformHandleui64NV(d)
}
func (*binaryClassGlProgramUniformHandleui64NV) Schema() *schema.Class {
	return schemaGlProgramUniformHandleui64NV
}

var schemaGlProgramUniformHandleui64NV = &schema.Class{
	TypeID:  binaryIDGlProgramUniformHandleui64NV,
	Package: "gles",
	Name:    "GlProgramUniformHandleui64NV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlProgramUniformHandleui64vNV struct{}

func (*GlProgramUniformHandleui64vNV) Class() binary.Class {
	return (*binaryClassGlProgramUniformHandleui64vNV)(nil)
}
func doEncodeGlProgramUniformHandleui64vNV(e binary.Encoder, o *GlProgramUniformHandleui64vNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformHandleui64vNV(d binary.Decoder, o *GlProgramUniformHandleui64vNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformHandleui64vNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuint64ᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformHandleui64vNV) ID() binary.ID {
	return binaryIDGlProgramUniformHandleui64vNV
}
func (*binaryClassGlProgramUniformHandleui64vNV) New() binary.Object {
	return &GlProgramUniformHandleui64vNV{}
}
func (*binaryClassGlProgramUniformHandleui64vNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformHandleui64vNV(e, obj.(*GlProgramUniformHandleui64vNV))
}
func (*binaryClassGlProgramUniformHandleui64vNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformHandleui64vNV{}
	return obj, doDecodeGlProgramUniformHandleui64vNV(d, obj)
}
func (*binaryClassGlProgramUniformHandleui64vNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformHandleui64vNV(d, obj.(*GlProgramUniformHandleui64vNV))
}
func (*binaryClassGlProgramUniformHandleui64vNV) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformHandleui64vNV(d)
}
func (*binaryClassGlProgramUniformHandleui64vNV) Schema() *schema.Class {
	return schemaGlProgramUniformHandleui64vNV
}

var schemaGlProgramUniformHandleui64vNV = &schema.Class{
	TypeID:  binaryIDGlProgramUniformHandleui64vNV,
	Package: "gles",
	Name:    "GlProgramUniformHandleui64vNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLuint64ᶜᵖ", ID: (*GLuint64ᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2fv struct{}

func (*GlProgramUniformMatrix2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2fv)(nil)
}
func doEncodeGlProgramUniformMatrix2fv(e binary.Encoder, o *GlProgramUniformMatrix2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2fv(d binary.Decoder, o *GlProgramUniformMatrix2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2fv) ID() binary.ID      { return binaryIDGlProgramUniformMatrix2fv }
func (*binaryClassGlProgramUniformMatrix2fv) New() binary.Object { return &GlProgramUniformMatrix2fv{} }
func (*binaryClassGlProgramUniformMatrix2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2fv(e, obj.(*GlProgramUniformMatrix2fv))
}
func (*binaryClassGlProgramUniformMatrix2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2fv{}
	return obj, doDecodeGlProgramUniformMatrix2fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2fv(d, obj.(*GlProgramUniformMatrix2fv))
}
func (*binaryClassGlProgramUniformMatrix2fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2fv(d)
}
func (*binaryClassGlProgramUniformMatrix2fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2fv
}

var schemaGlProgramUniformMatrix2fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2fvEXT struct{}

func (*GlProgramUniformMatrix2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix2fvEXT
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2fvEXT(e, obj.(*GlProgramUniformMatrix2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix2fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2fvEXT(d, obj.(*GlProgramUniformMatrix2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix2fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2fvEXT
}

var schemaGlProgramUniformMatrix2fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2x3fv struct{}

func (*GlProgramUniformMatrix2x3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x3fv)(nil)
}
func doEncodeGlProgramUniformMatrix2x3fv(e binary.Encoder, o *GlProgramUniformMatrix2x3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2x3fv(d binary.Decoder, o *GlProgramUniformMatrix2x3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2x3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2x3fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix2x3fv
}
func (*binaryClassGlProgramUniformMatrix2x3fv) New() binary.Object {
	return &GlProgramUniformMatrix2x3fv{}
}
func (*binaryClassGlProgramUniformMatrix2x3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2x3fv(e, obj.(*GlProgramUniformMatrix2x3fv))
}
func (*binaryClassGlProgramUniformMatrix2x3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2x3fv{}
	return obj, doDecodeGlProgramUniformMatrix2x3fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2x3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2x3fv(d, obj.(*GlProgramUniformMatrix2x3fv))
}
func (*binaryClassGlProgramUniformMatrix2x3fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2x3fv(d)
}
func (*binaryClassGlProgramUniformMatrix2x3fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2x3fv
}

var schemaGlProgramUniformMatrix2x3fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2x3fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2x3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2x3fvEXT struct{}

func (*GlProgramUniformMatrix2x3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2x3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2x3fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x3fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2x3fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix2x3fvEXT
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2x3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2x3fvEXT(e, obj.(*GlProgramUniformMatrix2x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2x3fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix2x3fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2x3fvEXT(d, obj.(*GlProgramUniformMatrix2x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2x3fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix2x3fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2x3fvEXT
}

var schemaGlProgramUniformMatrix2x3fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2x3fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2x3fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2x4fv struct{}

func (*GlProgramUniformMatrix2x4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x4fv)(nil)
}
func doEncodeGlProgramUniformMatrix2x4fv(e binary.Encoder, o *GlProgramUniformMatrix2x4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2x4fv(d binary.Decoder, o *GlProgramUniformMatrix2x4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2x4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2x4fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix2x4fv
}
func (*binaryClassGlProgramUniformMatrix2x4fv) New() binary.Object {
	return &GlProgramUniformMatrix2x4fv{}
}
func (*binaryClassGlProgramUniformMatrix2x4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2x4fv(e, obj.(*GlProgramUniformMatrix2x4fv))
}
func (*binaryClassGlProgramUniformMatrix2x4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2x4fv{}
	return obj, doDecodeGlProgramUniformMatrix2x4fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2x4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2x4fv(d, obj.(*GlProgramUniformMatrix2x4fv))
}
func (*binaryClassGlProgramUniformMatrix2x4fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2x4fv(d)
}
func (*binaryClassGlProgramUniformMatrix2x4fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2x4fv
}

var schemaGlProgramUniformMatrix2x4fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2x4fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2x4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix2x4fvEXT struct{}

func (*GlProgramUniformMatrix2x4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix2x4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix2x4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix2x4fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix2x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix2x4fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix2x4fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix2x4fvEXT
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix2x4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix2x4fvEXT(e, obj.(*GlProgramUniformMatrix2x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix2x4fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix2x4fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix2x4fvEXT(d, obj.(*GlProgramUniformMatrix2x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix2x4fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix2x4fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix2x4fvEXT
}

var schemaGlProgramUniformMatrix2x4fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix2x4fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix2x4fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3fv struct{}

func (*GlProgramUniformMatrix3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3fv)(nil)
}
func doEncodeGlProgramUniformMatrix3fv(e binary.Encoder, o *GlProgramUniformMatrix3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3fv(d binary.Decoder, o *GlProgramUniformMatrix3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3fv) ID() binary.ID      { return binaryIDGlProgramUniformMatrix3fv }
func (*binaryClassGlProgramUniformMatrix3fv) New() binary.Object { return &GlProgramUniformMatrix3fv{} }
func (*binaryClassGlProgramUniformMatrix3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3fv(e, obj.(*GlProgramUniformMatrix3fv))
}
func (*binaryClassGlProgramUniformMatrix3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3fv{}
	return obj, doDecodeGlProgramUniformMatrix3fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3fv(d, obj.(*GlProgramUniformMatrix3fv))
}
func (*binaryClassGlProgramUniformMatrix3fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3fv(d)
}
func (*binaryClassGlProgramUniformMatrix3fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3fv
}

var schemaGlProgramUniformMatrix3fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3fvEXT struct{}

func (*GlProgramUniformMatrix3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix3fvEXT
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3fvEXT(e, obj.(*GlProgramUniformMatrix3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix3fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3fvEXT(d, obj.(*GlProgramUniformMatrix3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix3fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3fvEXT
}

var schemaGlProgramUniformMatrix3fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3x2fv struct{}

func (*GlProgramUniformMatrix3x2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x2fv)(nil)
}
func doEncodeGlProgramUniformMatrix3x2fv(e binary.Encoder, o *GlProgramUniformMatrix3x2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3x2fv(d binary.Decoder, o *GlProgramUniformMatrix3x2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3x2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3x2fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix3x2fv
}
func (*binaryClassGlProgramUniformMatrix3x2fv) New() binary.Object {
	return &GlProgramUniformMatrix3x2fv{}
}
func (*binaryClassGlProgramUniformMatrix3x2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3x2fv(e, obj.(*GlProgramUniformMatrix3x2fv))
}
func (*binaryClassGlProgramUniformMatrix3x2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3x2fv{}
	return obj, doDecodeGlProgramUniformMatrix3x2fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3x2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3x2fv(d, obj.(*GlProgramUniformMatrix3x2fv))
}
func (*binaryClassGlProgramUniformMatrix3x2fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3x2fv(d)
}
func (*binaryClassGlProgramUniformMatrix3x2fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3x2fv
}

var schemaGlProgramUniformMatrix3x2fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3x2fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3x2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3x2fvEXT struct{}

func (*GlProgramUniformMatrix3x2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3x2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3x2fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x2fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3x2fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix3x2fvEXT
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3x2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3x2fvEXT(e, obj.(*GlProgramUniformMatrix3x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3x2fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix3x2fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3x2fvEXT(d, obj.(*GlProgramUniformMatrix3x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3x2fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix3x2fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3x2fvEXT
}

var schemaGlProgramUniformMatrix3x2fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3x2fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3x2fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3x4fv struct{}

func (*GlProgramUniformMatrix3x4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x4fv)(nil)
}
func doEncodeGlProgramUniformMatrix3x4fv(e binary.Encoder, o *GlProgramUniformMatrix3x4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3x4fv(d binary.Decoder, o *GlProgramUniformMatrix3x4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3x4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3x4fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix3x4fv
}
func (*binaryClassGlProgramUniformMatrix3x4fv) New() binary.Object {
	return &GlProgramUniformMatrix3x4fv{}
}
func (*binaryClassGlProgramUniformMatrix3x4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3x4fv(e, obj.(*GlProgramUniformMatrix3x4fv))
}
func (*binaryClassGlProgramUniformMatrix3x4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3x4fv{}
	return obj, doDecodeGlProgramUniformMatrix3x4fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3x4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3x4fv(d, obj.(*GlProgramUniformMatrix3x4fv))
}
func (*binaryClassGlProgramUniformMatrix3x4fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3x4fv(d)
}
func (*binaryClassGlProgramUniformMatrix3x4fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3x4fv
}

var schemaGlProgramUniformMatrix3x4fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3x4fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3x4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix3x4fvEXT struct{}

func (*GlProgramUniformMatrix3x4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix3x4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix3x4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix3x4fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix3x4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix3x4fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix3x4fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix3x4fvEXT
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix3x4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix3x4fvEXT(e, obj.(*GlProgramUniformMatrix3x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix3x4fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix3x4fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix3x4fvEXT(d, obj.(*GlProgramUniformMatrix3x4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix3x4fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix3x4fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix3x4fvEXT
}

var schemaGlProgramUniformMatrix3x4fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix3x4fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix3x4fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4fv struct{}

func (*GlProgramUniformMatrix4fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4fv)(nil)
}
func doEncodeGlProgramUniformMatrix4fv(e binary.Encoder, o *GlProgramUniformMatrix4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4fv(d binary.Decoder, o *GlProgramUniformMatrix4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4fv) ID() binary.ID      { return binaryIDGlProgramUniformMatrix4fv }
func (*binaryClassGlProgramUniformMatrix4fv) New() binary.Object { return &GlProgramUniformMatrix4fv{} }
func (*binaryClassGlProgramUniformMatrix4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4fv(e, obj.(*GlProgramUniformMatrix4fv))
}
func (*binaryClassGlProgramUniformMatrix4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4fv{}
	return obj, doDecodeGlProgramUniformMatrix4fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4fv(d, obj.(*GlProgramUniformMatrix4fv))
}
func (*binaryClassGlProgramUniformMatrix4fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4fv(d)
}
func (*binaryClassGlProgramUniformMatrix4fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4fv
}

var schemaGlProgramUniformMatrix4fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4fvEXT struct{}

func (*GlProgramUniformMatrix4fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix4fvEXT
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4fvEXT(e, obj.(*GlProgramUniformMatrix4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix4fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4fvEXT(d, obj.(*GlProgramUniformMatrix4fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix4fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4fvEXT
}

var schemaGlProgramUniformMatrix4fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4x2fv struct{}

func (*GlProgramUniformMatrix4x2fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x2fv)(nil)
}
func doEncodeGlProgramUniformMatrix4x2fv(e binary.Encoder, o *GlProgramUniformMatrix4x2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4x2fv(d binary.Decoder, o *GlProgramUniformMatrix4x2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4x2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4x2fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix4x2fv
}
func (*binaryClassGlProgramUniformMatrix4x2fv) New() binary.Object {
	return &GlProgramUniformMatrix4x2fv{}
}
func (*binaryClassGlProgramUniformMatrix4x2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4x2fv(e, obj.(*GlProgramUniformMatrix4x2fv))
}
func (*binaryClassGlProgramUniformMatrix4x2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4x2fv{}
	return obj, doDecodeGlProgramUniformMatrix4x2fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4x2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4x2fv(d, obj.(*GlProgramUniformMatrix4x2fv))
}
func (*binaryClassGlProgramUniformMatrix4x2fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4x2fv(d)
}
func (*binaryClassGlProgramUniformMatrix4x2fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4x2fv
}

var schemaGlProgramUniformMatrix4x2fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4x2fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4x2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4x2fvEXT struct{}

func (*GlProgramUniformMatrix4x2fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x2fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4x2fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4x2fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4x2fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x2fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4x2fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix4x2fvEXT
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4x2fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4x2fvEXT(e, obj.(*GlProgramUniformMatrix4x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4x2fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix4x2fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4x2fvEXT(d, obj.(*GlProgramUniformMatrix4x2fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4x2fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix4x2fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4x2fvEXT
}

var schemaGlProgramUniformMatrix4x2fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4x2fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4x2fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4x3fv struct{}

func (*GlProgramUniformMatrix4x3fv) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x3fv)(nil)
}
func doEncodeGlProgramUniformMatrix4x3fv(e binary.Encoder, o *GlProgramUniformMatrix4x3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4x3fv(d binary.Decoder, o *GlProgramUniformMatrix4x3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4x3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4x3fv) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix4x3fv
}
func (*binaryClassGlProgramUniformMatrix4x3fv) New() binary.Object {
	return &GlProgramUniformMatrix4x3fv{}
}
func (*binaryClassGlProgramUniformMatrix4x3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4x3fv(e, obj.(*GlProgramUniformMatrix4x3fv))
}
func (*binaryClassGlProgramUniformMatrix4x3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4x3fv{}
	return obj, doDecodeGlProgramUniformMatrix4x3fv(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4x3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4x3fv(d, obj.(*GlProgramUniformMatrix4x3fv))
}
func (*binaryClassGlProgramUniformMatrix4x3fv) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4x3fv(d)
}
func (*binaryClassGlProgramUniformMatrix4x3fv) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4x3fv
}

var schemaGlProgramUniformMatrix4x3fv = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4x3fv,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4x3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlProgramUniformMatrix4x3fvEXT struct{}

func (*GlProgramUniformMatrix4x3fvEXT) Class() binary.Class {
	return (*binaryClassGlProgramUniformMatrix4x3fvEXT)(nil)
}
func doEncodeGlProgramUniformMatrix4x3fvEXT(e binary.Encoder, o *GlProgramUniformMatrix4x3fvEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlProgramUniformMatrix4x3fvEXT(d binary.Decoder, o *GlProgramUniformMatrix4x3fvEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlProgramUniformMatrix4x3fvEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) ID() binary.ID {
	return binaryIDGlProgramUniformMatrix4x3fvEXT
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) New() binary.Object {
	return &GlProgramUniformMatrix4x3fvEXT{}
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlProgramUniformMatrix4x3fvEXT(e, obj.(*GlProgramUniformMatrix4x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlProgramUniformMatrix4x3fvEXT{}
	return obj, doDecodeGlProgramUniformMatrix4x3fvEXT(d, obj)
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlProgramUniformMatrix4x3fvEXT(d, obj.(*GlProgramUniformMatrix4x3fvEXT))
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) Skip(d binary.Decoder) error {
	return doSkipGlProgramUniformMatrix4x3fvEXT(d)
}
func (*binaryClassGlProgramUniformMatrix4x3fvEXT) Schema() *schema.Class {
	return schemaGlProgramUniformMatrix4x3fvEXT
}

var schemaGlProgramUniformMatrix4x3fvEXT = &schema.Class{
	TypeID:  binaryIDGlProgramUniformMatrix4x3fvEXT,
	Package: "gles",
	Name:    "GlProgramUniformMatrix4x3fvEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPushDebugGroupKHR struct{}

func (*GlPushDebugGroupKHR) Class() binary.Class {
	return (*binaryClassGlPushDebugGroupKHR)(nil)
}
func doEncodeGlPushDebugGroupKHR(e binary.Encoder, o *GlPushDebugGroupKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Source)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Id)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Message); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPushDebugGroupKHR(d binary.Decoder, o *GlPushDebugGroupKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Source = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Message); err != nil {
		return err
	}
	return nil
}
func doSkipGlPushDebugGroupKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPushDebugGroupKHR) ID() binary.ID      { return binaryIDGlPushDebugGroupKHR }
func (*binaryClassGlPushDebugGroupKHR) New() binary.Object { return &GlPushDebugGroupKHR{} }
func (*binaryClassGlPushDebugGroupKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPushDebugGroupKHR(e, obj.(*GlPushDebugGroupKHR))
}
func (*binaryClassGlPushDebugGroupKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPushDebugGroupKHR{}
	return obj, doDecodeGlPushDebugGroupKHR(d, obj)
}
func (*binaryClassGlPushDebugGroupKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPushDebugGroupKHR(d, obj.(*GlPushDebugGroupKHR))
}
func (*binaryClassGlPushDebugGroupKHR) Skip(d binary.Decoder) error {
	return doSkipGlPushDebugGroupKHR(d)
}
func (*binaryClassGlPushDebugGroupKHR) Schema() *schema.Class { return schemaGlPushDebugGroupKHR }

var schemaGlPushDebugGroupKHR = &schema.Class{
	TypeID:  binaryIDGlPushDebugGroupKHR,
	Package: "gles",
	Name:    "GlPushDebugGroupKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Source", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Id", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Message", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlPushGroupMarkerEXT struct{}

func (*GlPushGroupMarkerEXT) Class() binary.Class {
	return (*binaryClassGlPushGroupMarkerEXT)(nil)
}
func doEncodeGlPushGroupMarkerEXT(e binary.Encoder, o *GlPushGroupMarkerEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Length)); err != nil {
		return err
	}
	if err := e.Value(&o.Marker); err != nil {
		return err
	}
	return nil
}
func doDecodeGlPushGroupMarkerEXT(d binary.Decoder, o *GlPushGroupMarkerEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Length = GLsizei(obj)
	}
	if err := d.Value(&o.Marker); err != nil {
		return err
	}
	return nil
}
func doSkipGlPushGroupMarkerEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlPushGroupMarkerEXT) ID() binary.ID      { return binaryIDGlPushGroupMarkerEXT }
func (*binaryClassGlPushGroupMarkerEXT) New() binary.Object { return &GlPushGroupMarkerEXT{} }
func (*binaryClassGlPushGroupMarkerEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlPushGroupMarkerEXT(e, obj.(*GlPushGroupMarkerEXT))
}
func (*binaryClassGlPushGroupMarkerEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlPushGroupMarkerEXT{}
	return obj, doDecodeGlPushGroupMarkerEXT(d, obj)
}
func (*binaryClassGlPushGroupMarkerEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlPushGroupMarkerEXT(d, obj.(*GlPushGroupMarkerEXT))
}
func (*binaryClassGlPushGroupMarkerEXT) Skip(d binary.Decoder) error {
	return doSkipGlPushGroupMarkerEXT(d)
}
func (*binaryClassGlPushGroupMarkerEXT) Schema() *schema.Class { return schemaGlPushGroupMarkerEXT }

var schemaGlPushGroupMarkerEXT = &schema.Class{
	TypeID:  binaryIDGlPushGroupMarkerEXT,
	Package: "gles",
	Name:    "GlPushGroupMarkerEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Marker", Type: &schema.Struct{Name: "GLcharᶜᵖ", ID: (*GLcharᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlQueryCounterEXT struct{}

func (*GlQueryCounterEXT) Class() binary.Class {
	return (*binaryClassGlQueryCounterEXT)(nil)
}
func doEncodeGlQueryCounterEXT(e binary.Encoder, o *GlQueryCounterEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Query)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlQueryCounterEXT(d binary.Decoder, o *GlQueryCounterEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Query = QueryId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	return nil
}
func doSkipGlQueryCounterEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlQueryCounterEXT) ID() binary.ID      { return binaryIDGlQueryCounterEXT }
func (*binaryClassGlQueryCounterEXT) New() binary.Object { return &GlQueryCounterEXT{} }
func (*binaryClassGlQueryCounterEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlQueryCounterEXT(e, obj.(*GlQueryCounterEXT))
}
func (*binaryClassGlQueryCounterEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlQueryCounterEXT{}
	return obj, doDecodeGlQueryCounterEXT(d, obj)
}
func (*binaryClassGlQueryCounterEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlQueryCounterEXT(d, obj.(*GlQueryCounterEXT))
}
func (*binaryClassGlQueryCounterEXT) Skip(d binary.Decoder) error { return doSkipGlQueryCounterEXT(d) }
func (*binaryClassGlQueryCounterEXT) Schema() *schema.Class       { return schemaGlQueryCounterEXT }

var schemaGlQueryCounterEXT = &schema.Class{
	TypeID:  binaryIDGlQueryCounterEXT,
	Package: "gles",
	Name:    "GlQueryCounterEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlRasterSamplesEXT struct{}

func (*GlRasterSamplesEXT) Class() binary.Class {
	return (*binaryClassGlRasterSamplesEXT)(nil)
}
func doEncodeGlRasterSamplesEXT(e binary.Encoder, o *GlRasterSamplesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Fixedsamplelocations)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRasterSamplesEXT(d binary.Decoder, o *GlRasterSamplesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Samples = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Fixedsamplelocations = GLboolean(obj)
	}
	return nil
}
func doSkipGlRasterSamplesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRasterSamplesEXT) ID() binary.ID      { return binaryIDGlRasterSamplesEXT }
func (*binaryClassGlRasterSamplesEXT) New() binary.Object { return &GlRasterSamplesEXT{} }
func (*binaryClassGlRasterSamplesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRasterSamplesEXT(e, obj.(*GlRasterSamplesEXT))
}
func (*binaryClassGlRasterSamplesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRasterSamplesEXT{}
	return obj, doDecodeGlRasterSamplesEXT(d, obj)
}
func (*binaryClassGlRasterSamplesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRasterSamplesEXT(d, obj.(*GlRasterSamplesEXT))
}
func (*binaryClassGlRasterSamplesEXT) Skip(d binary.Decoder) error { return doSkipGlRasterSamplesEXT(d) }
func (*binaryClassGlRasterSamplesEXT) Schema() *schema.Class       { return schemaGlRasterSamplesEXT }

var schemaGlRasterSamplesEXT = &schema.Class{
	TypeID:  binaryIDGlRasterSamplesEXT,
	Package: "gles",
	Name:    "GlRasterSamplesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Fixedsamplelocations", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlReadBuffer struct{}

func (*GlReadBuffer) Class() binary.Class {
	return (*binaryClassGlReadBuffer)(nil)
}
func doEncodeGlReadBuffer(e binary.Encoder, o *GlReadBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Src)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadBuffer(d binary.Decoder, o *GlReadBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Src = GLenum(obj)
	}
	return nil
}
func doSkipGlReadBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadBuffer) ID() binary.ID      { return binaryIDGlReadBuffer }
func (*binaryClassGlReadBuffer) New() binary.Object { return &GlReadBuffer{} }
func (*binaryClassGlReadBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadBuffer(e, obj.(*GlReadBuffer))
}
func (*binaryClassGlReadBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadBuffer{}
	return obj, doDecodeGlReadBuffer(d, obj)
}
func (*binaryClassGlReadBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadBuffer(d, obj.(*GlReadBuffer))
}
func (*binaryClassGlReadBuffer) Skip(d binary.Decoder) error { return doSkipGlReadBuffer(d) }
func (*binaryClassGlReadBuffer) Schema() *schema.Class       { return schemaGlReadBuffer }

var schemaGlReadBuffer = &schema.Class{
	TypeID:  binaryIDGlReadBuffer,
	Package: "gles",
	Name:    "GlReadBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Src", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlReadBufferIndexedEXT struct{}

func (*GlReadBufferIndexedEXT) Class() binary.Class {
	return (*binaryClassGlReadBufferIndexedEXT)(nil)
}
func doEncodeGlReadBufferIndexedEXT(e binary.Encoder, o *GlReadBufferIndexedEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Src)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Index)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadBufferIndexedEXT(d binary.Decoder, o *GlReadBufferIndexedEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Src = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Index = GLint(obj)
	}
	return nil
}
func doSkipGlReadBufferIndexedEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadBufferIndexedEXT) ID() binary.ID      { return binaryIDGlReadBufferIndexedEXT }
func (*binaryClassGlReadBufferIndexedEXT) New() binary.Object { return &GlReadBufferIndexedEXT{} }
func (*binaryClassGlReadBufferIndexedEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadBufferIndexedEXT(e, obj.(*GlReadBufferIndexedEXT))
}
func (*binaryClassGlReadBufferIndexedEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadBufferIndexedEXT{}
	return obj, doDecodeGlReadBufferIndexedEXT(d, obj)
}
func (*binaryClassGlReadBufferIndexedEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadBufferIndexedEXT(d, obj.(*GlReadBufferIndexedEXT))
}
func (*binaryClassGlReadBufferIndexedEXT) Skip(d binary.Decoder) error {
	return doSkipGlReadBufferIndexedEXT(d)
}
func (*binaryClassGlReadBufferIndexedEXT) Schema() *schema.Class { return schemaGlReadBufferIndexedEXT }

var schemaGlReadBufferIndexedEXT = &schema.Class{
	TypeID:  binaryIDGlReadBufferIndexedEXT,
	Package: "gles",
	Name:    "GlReadBufferIndexedEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Src", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlReadBufferNV struct{}

func (*GlReadBufferNV) Class() binary.Class {
	return (*binaryClassGlReadBufferNV)(nil)
}
func doEncodeGlReadBufferNV(e binary.Encoder, o *GlReadBufferNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadBufferNV(d binary.Decoder, o *GlReadBufferNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mode = GLenum(obj)
	}
	return nil
}
func doSkipGlReadBufferNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadBufferNV) ID() binary.ID      { return binaryIDGlReadBufferNV }
func (*binaryClassGlReadBufferNV) New() binary.Object { return &GlReadBufferNV{} }
func (*binaryClassGlReadBufferNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadBufferNV(e, obj.(*GlReadBufferNV))
}
func (*binaryClassGlReadBufferNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadBufferNV{}
	return obj, doDecodeGlReadBufferNV(d, obj)
}
func (*binaryClassGlReadBufferNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadBufferNV(d, obj.(*GlReadBufferNV))
}
func (*binaryClassGlReadBufferNV) Skip(d binary.Decoder) error { return doSkipGlReadBufferNV(d) }
func (*binaryClassGlReadBufferNV) Schema() *schema.Class       { return schemaGlReadBufferNV }

var schemaGlReadBufferNV = &schema.Class{
	TypeID:  binaryIDGlReadBufferNV,
	Package: "gles",
	Name:    "GlReadBufferNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlReadPixels struct{}

func (*GlReadPixels) Class() binary.Class {
	return (*binaryClassGlReadPixels)(nil)
}
func doEncodeGlReadPixels(e binary.Encoder, o *GlReadPixels) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadPixels(d binary.Decoder, o *GlReadPixels) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlReadPixels(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadPixels) ID() binary.ID      { return binaryIDGlReadPixels }
func (*binaryClassGlReadPixels) New() binary.Object { return &GlReadPixels{} }
func (*binaryClassGlReadPixels) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadPixels(e, obj.(*GlReadPixels))
}
func (*binaryClassGlReadPixels) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadPixels{}
	return obj, doDecodeGlReadPixels(d, obj)
}
func (*binaryClassGlReadPixels) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadPixels(d, obj.(*GlReadPixels))
}
func (*binaryClassGlReadPixels) Skip(d binary.Decoder) error { return doSkipGlReadPixels(d) }
func (*binaryClassGlReadPixels) Schema() *schema.Class       { return schemaGlReadPixels }

var schemaGlReadPixels = &schema.Class{
	TypeID:  binaryIDGlReadPixels,
	Package: "gles",
	Name:    "GlReadPixels",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlReadnPixelsEXT struct{}

func (*GlReadnPixelsEXT) Class() binary.Class {
	return (*binaryClassGlReadnPixelsEXT)(nil)
}
func doEncodeGlReadnPixelsEXT(e binary.Encoder, o *GlReadnPixelsEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadnPixelsEXT(d binary.Decoder, o *GlReadnPixelsEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlReadnPixelsEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadnPixelsEXT) ID() binary.ID      { return binaryIDGlReadnPixelsEXT }
func (*binaryClassGlReadnPixelsEXT) New() binary.Object { return &GlReadnPixelsEXT{} }
func (*binaryClassGlReadnPixelsEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadnPixelsEXT(e, obj.(*GlReadnPixelsEXT))
}
func (*binaryClassGlReadnPixelsEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadnPixelsEXT{}
	return obj, doDecodeGlReadnPixelsEXT(d, obj)
}
func (*binaryClassGlReadnPixelsEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadnPixelsEXT(d, obj.(*GlReadnPixelsEXT))
}
func (*binaryClassGlReadnPixelsEXT) Skip(d binary.Decoder) error { return doSkipGlReadnPixelsEXT(d) }
func (*binaryClassGlReadnPixelsEXT) Schema() *schema.Class       { return schemaGlReadnPixelsEXT }

var schemaGlReadnPixelsEXT = &schema.Class{
	TypeID:  binaryIDGlReadnPixelsEXT,
	Package: "gles",
	Name:    "GlReadnPixelsEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlReadnPixelsKHR struct{}

func (*GlReadnPixelsKHR) Class() binary.Class {
	return (*binaryClassGlReadnPixelsKHR)(nil)
}
func doEncodeGlReadnPixelsKHR(e binary.Encoder, o *GlReadnPixelsKHR) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BufSize)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReadnPixelsKHR(d binary.Decoder, o *GlReadnPixelsKHR) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BufSize = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlReadnPixelsKHR(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReadnPixelsKHR) ID() binary.ID      { return binaryIDGlReadnPixelsKHR }
func (*binaryClassGlReadnPixelsKHR) New() binary.Object { return &GlReadnPixelsKHR{} }
func (*binaryClassGlReadnPixelsKHR) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReadnPixelsKHR(e, obj.(*GlReadnPixelsKHR))
}
func (*binaryClassGlReadnPixelsKHR) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReadnPixelsKHR{}
	return obj, doDecodeGlReadnPixelsKHR(d, obj)
}
func (*binaryClassGlReadnPixelsKHR) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReadnPixelsKHR(d, obj.(*GlReadnPixelsKHR))
}
func (*binaryClassGlReadnPixelsKHR) Skip(d binary.Decoder) error { return doSkipGlReadnPixelsKHR(d) }
func (*binaryClassGlReadnPixelsKHR) Schema() *schema.Class       { return schemaGlReadnPixelsKHR }

var schemaGlReadnPixelsKHR = &schema.Class{
	TypeID:  binaryIDGlReadnPixelsKHR,
	Package: "gles",
	Name:    "GlReadnPixelsKHR",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "BufSize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlReleaseShaderCompiler struct{}

func (*GlReleaseShaderCompiler) Class() binary.Class {
	return (*binaryClassGlReleaseShaderCompiler)(nil)
}
func doEncodeGlReleaseShaderCompiler(e binary.Encoder, o *GlReleaseShaderCompiler) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlReleaseShaderCompiler(d binary.Decoder, o *GlReleaseShaderCompiler) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlReleaseShaderCompiler(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlReleaseShaderCompiler) ID() binary.ID      { return binaryIDGlReleaseShaderCompiler }
func (*binaryClassGlReleaseShaderCompiler) New() binary.Object { return &GlReleaseShaderCompiler{} }
func (*binaryClassGlReleaseShaderCompiler) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlReleaseShaderCompiler(e, obj.(*GlReleaseShaderCompiler))
}
func (*binaryClassGlReleaseShaderCompiler) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlReleaseShaderCompiler{}
	return obj, doDecodeGlReleaseShaderCompiler(d, obj)
}
func (*binaryClassGlReleaseShaderCompiler) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlReleaseShaderCompiler(d, obj.(*GlReleaseShaderCompiler))
}
func (*binaryClassGlReleaseShaderCompiler) Skip(d binary.Decoder) error {
	return doSkipGlReleaseShaderCompiler(d)
}
func (*binaryClassGlReleaseShaderCompiler) Schema() *schema.Class {
	return schemaGlReleaseShaderCompiler
}

var schemaGlReleaseShaderCompiler = &schema.Class{
	TypeID:  binaryIDGlReleaseShaderCompiler,
	Package: "gles",
	Name:    "GlReleaseShaderCompiler",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlRenderbufferStorage struct{}

func (*GlRenderbufferStorage) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorage)(nil)
}
func doEncodeGlRenderbufferStorage(e binary.Encoder, o *GlRenderbufferStorage) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorage(d binary.Decoder, o *GlRenderbufferStorage) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorage(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorage) ID() binary.ID      { return binaryIDGlRenderbufferStorage }
func (*binaryClassGlRenderbufferStorage) New() binary.Object { return &GlRenderbufferStorage{} }
func (*binaryClassGlRenderbufferStorage) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorage(e, obj.(*GlRenderbufferStorage))
}
func (*binaryClassGlRenderbufferStorage) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorage{}
	return obj, doDecodeGlRenderbufferStorage(d, obj)
}
func (*binaryClassGlRenderbufferStorage) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorage(d, obj.(*GlRenderbufferStorage))
}
func (*binaryClassGlRenderbufferStorage) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorage(d)
}
func (*binaryClassGlRenderbufferStorage) Schema() *schema.Class { return schemaGlRenderbufferStorage }

var schemaGlRenderbufferStorage = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorage,
	Package: "gles",
	Name:    "GlRenderbufferStorage",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisample struct{}

func (*GlRenderbufferStorageMultisample) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisample)(nil)
}
func doEncodeGlRenderbufferStorageMultisample(e binary.Encoder, o *GlRenderbufferStorageMultisample) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisample(d binary.Decoder, o *GlRenderbufferStorageMultisample) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisample(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisample) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisample
}
func (*binaryClassGlRenderbufferStorageMultisample) New() binary.Object {
	return &GlRenderbufferStorageMultisample{}
}
func (*binaryClassGlRenderbufferStorageMultisample) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisample(e, obj.(*GlRenderbufferStorageMultisample))
}
func (*binaryClassGlRenderbufferStorageMultisample) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisample{}
	return obj, doDecodeGlRenderbufferStorageMultisample(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisample) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisample(d, obj.(*GlRenderbufferStorageMultisample))
}
func (*binaryClassGlRenderbufferStorageMultisample) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisample(d)
}
func (*binaryClassGlRenderbufferStorageMultisample) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisample
}

var schemaGlRenderbufferStorageMultisample = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisample,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisample",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisampleANGLE struct{}

func (*GlRenderbufferStorageMultisampleANGLE) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleANGLE)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleANGLE(e binary.Encoder, o *GlRenderbufferStorageMultisampleANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisampleANGLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisampleANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisampleANGLE
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) New() binary.Object {
	return &GlRenderbufferStorageMultisampleANGLE{}
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisampleANGLE(e, obj.(*GlRenderbufferStorageMultisampleANGLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisampleANGLE{}
	return obj, doDecodeGlRenderbufferStorageMultisampleANGLE(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisampleANGLE(d, obj.(*GlRenderbufferStorageMultisampleANGLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisampleANGLE(d)
}
func (*binaryClassGlRenderbufferStorageMultisampleANGLE) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisampleANGLE
}

var schemaGlRenderbufferStorageMultisampleANGLE = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisampleANGLE,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisampleANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisampleAPPLE struct{}

func (*GlRenderbufferStorageMultisampleAPPLE) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleAPPLE)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleAPPLE(e binary.Encoder, o *GlRenderbufferStorageMultisampleAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisampleAPPLE(d binary.Decoder, o *GlRenderbufferStorageMultisampleAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisampleAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisampleAPPLE
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) New() binary.Object {
	return &GlRenderbufferStorageMultisampleAPPLE{}
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisampleAPPLE(e, obj.(*GlRenderbufferStorageMultisampleAPPLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisampleAPPLE{}
	return obj, doDecodeGlRenderbufferStorageMultisampleAPPLE(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisampleAPPLE(d, obj.(*GlRenderbufferStorageMultisampleAPPLE))
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisampleAPPLE(d)
}
func (*binaryClassGlRenderbufferStorageMultisampleAPPLE) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisampleAPPLE
}

var schemaGlRenderbufferStorageMultisampleAPPLE = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisampleAPPLE,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisampleAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisampleEXT struct{}

func (*GlRenderbufferStorageMultisampleEXT) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleEXT)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleEXT(e binary.Encoder, o *GlRenderbufferStorageMultisampleEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisampleEXT(d binary.Decoder, o *GlRenderbufferStorageMultisampleEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisampleEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisampleEXT
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) New() binary.Object {
	return &GlRenderbufferStorageMultisampleEXT{}
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisampleEXT(e, obj.(*GlRenderbufferStorageMultisampleEXT))
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisampleEXT{}
	return obj, doDecodeGlRenderbufferStorageMultisampleEXT(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisampleEXT(d, obj.(*GlRenderbufferStorageMultisampleEXT))
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisampleEXT(d)
}
func (*binaryClassGlRenderbufferStorageMultisampleEXT) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisampleEXT
}

var schemaGlRenderbufferStorageMultisampleEXT = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisampleEXT,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisampleEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisampleIMG struct{}

func (*GlRenderbufferStorageMultisampleIMG) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleIMG)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleIMG(e binary.Encoder, o *GlRenderbufferStorageMultisampleIMG) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisampleIMG(d binary.Decoder, o *GlRenderbufferStorageMultisampleIMG) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisampleIMG(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisampleIMG
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) New() binary.Object {
	return &GlRenderbufferStorageMultisampleIMG{}
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisampleIMG(e, obj.(*GlRenderbufferStorageMultisampleIMG))
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisampleIMG{}
	return obj, doDecodeGlRenderbufferStorageMultisampleIMG(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisampleIMG(d, obj.(*GlRenderbufferStorageMultisampleIMG))
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisampleIMG(d)
}
func (*binaryClassGlRenderbufferStorageMultisampleIMG) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisampleIMG
}

var schemaGlRenderbufferStorageMultisampleIMG = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisampleIMG,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisampleIMG",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlRenderbufferStorageMultisampleNV struct{}

func (*GlRenderbufferStorageMultisampleNV) Class() binary.Class {
	return (*binaryClassGlRenderbufferStorageMultisampleNV)(nil)
}
func doEncodeGlRenderbufferStorageMultisampleNV(e binary.Encoder, o *GlRenderbufferStorageMultisampleNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlRenderbufferStorageMultisampleNV(d binary.Decoder, o *GlRenderbufferStorageMultisampleNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlRenderbufferStorageMultisampleNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) ID() binary.ID {
	return binaryIDGlRenderbufferStorageMultisampleNV
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) New() binary.Object {
	return &GlRenderbufferStorageMultisampleNV{}
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlRenderbufferStorageMultisampleNV(e, obj.(*GlRenderbufferStorageMultisampleNV))
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlRenderbufferStorageMultisampleNV{}
	return obj, doDecodeGlRenderbufferStorageMultisampleNV(d, obj)
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlRenderbufferStorageMultisampleNV(d, obj.(*GlRenderbufferStorageMultisampleNV))
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) Skip(d binary.Decoder) error {
	return doSkipGlRenderbufferStorageMultisampleNV(d)
}
func (*binaryClassGlRenderbufferStorageMultisampleNV) Schema() *schema.Class {
	return schemaGlRenderbufferStorageMultisampleNV
}

var schemaGlRenderbufferStorageMultisampleNV = &schema.Class{
	TypeID:  binaryIDGlRenderbufferStorageMultisampleNV,
	Package: "gles",
	Name:    "GlRenderbufferStorageMultisampleNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlResolveDepthValuesNV struct{}

func (*GlResolveDepthValuesNV) Class() binary.Class {
	return (*binaryClassGlResolveDepthValuesNV)(nil)
}
func doEncodeGlResolveDepthValuesNV(e binary.Encoder, o *GlResolveDepthValuesNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlResolveDepthValuesNV(d binary.Decoder, o *GlResolveDepthValuesNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlResolveDepthValuesNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlResolveDepthValuesNV) ID() binary.ID      { return binaryIDGlResolveDepthValuesNV }
func (*binaryClassGlResolveDepthValuesNV) New() binary.Object { return &GlResolveDepthValuesNV{} }
func (*binaryClassGlResolveDepthValuesNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlResolveDepthValuesNV(e, obj.(*GlResolveDepthValuesNV))
}
func (*binaryClassGlResolveDepthValuesNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlResolveDepthValuesNV{}
	return obj, doDecodeGlResolveDepthValuesNV(d, obj)
}
func (*binaryClassGlResolveDepthValuesNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlResolveDepthValuesNV(d, obj.(*GlResolveDepthValuesNV))
}
func (*binaryClassGlResolveDepthValuesNV) Skip(d binary.Decoder) error {
	return doSkipGlResolveDepthValuesNV(d)
}
func (*binaryClassGlResolveDepthValuesNV) Schema() *schema.Class { return schemaGlResolveDepthValuesNV }

var schemaGlResolveDepthValuesNV = &schema.Class{
	TypeID:  binaryIDGlResolveDepthValuesNV,
	Package: "gles",
	Name:    "GlResolveDepthValuesNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlResolveMultisampleFramebufferAPPLE struct{}

func (*GlResolveMultisampleFramebufferAPPLE) Class() binary.Class {
	return (*binaryClassGlResolveMultisampleFramebufferAPPLE)(nil)
}
func doEncodeGlResolveMultisampleFramebufferAPPLE(e binary.Encoder, o *GlResolveMultisampleFramebufferAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlResolveMultisampleFramebufferAPPLE(d binary.Decoder, o *GlResolveMultisampleFramebufferAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlResolveMultisampleFramebufferAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) ID() binary.ID {
	return binaryIDGlResolveMultisampleFramebufferAPPLE
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) New() binary.Object {
	return &GlResolveMultisampleFramebufferAPPLE{}
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlResolveMultisampleFramebufferAPPLE(e, obj.(*GlResolveMultisampleFramebufferAPPLE))
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlResolveMultisampleFramebufferAPPLE{}
	return obj, doDecodeGlResolveMultisampleFramebufferAPPLE(d, obj)
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlResolveMultisampleFramebufferAPPLE(d, obj.(*GlResolveMultisampleFramebufferAPPLE))
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) Skip(d binary.Decoder) error {
	return doSkipGlResolveMultisampleFramebufferAPPLE(d)
}
func (*binaryClassGlResolveMultisampleFramebufferAPPLE) Schema() *schema.Class {
	return schemaGlResolveMultisampleFramebufferAPPLE
}

var schemaGlResolveMultisampleFramebufferAPPLE = &schema.Class{
	TypeID:  binaryIDGlResolveMultisampleFramebufferAPPLE,
	Package: "gles",
	Name:    "GlResolveMultisampleFramebufferAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlResumeTransformFeedback struct{}

func (*GlResumeTransformFeedback) Class() binary.Class {
	return (*binaryClassGlResumeTransformFeedback)(nil)
}
func doEncodeGlResumeTransformFeedback(e binary.Encoder, o *GlResumeTransformFeedback) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeGlResumeTransformFeedback(d binary.Decoder, o *GlResumeTransformFeedback) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipGlResumeTransformFeedback(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlResumeTransformFeedback) ID() binary.ID      { return binaryIDGlResumeTransformFeedback }
func (*binaryClassGlResumeTransformFeedback) New() binary.Object { return &GlResumeTransformFeedback{} }
func (*binaryClassGlResumeTransformFeedback) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlResumeTransformFeedback(e, obj.(*GlResumeTransformFeedback))
}
func (*binaryClassGlResumeTransformFeedback) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlResumeTransformFeedback{}
	return obj, doDecodeGlResumeTransformFeedback(d, obj)
}
func (*binaryClassGlResumeTransformFeedback) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlResumeTransformFeedback(d, obj.(*GlResumeTransformFeedback))
}
func (*binaryClassGlResumeTransformFeedback) Skip(d binary.Decoder) error {
	return doSkipGlResumeTransformFeedback(d)
}
func (*binaryClassGlResumeTransformFeedback) Schema() *schema.Class {
	return schemaGlResumeTransformFeedback
}

var schemaGlResumeTransformFeedback = &schema.Class{
	TypeID:  binaryIDGlResumeTransformFeedback,
	Package: "gles",
	Name:    "GlResumeTransformFeedback",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassGlSampleCoverage struct{}

func (*GlSampleCoverage) Class() binary.Class {
	return (*binaryClassGlSampleCoverage)(nil)
}
func doEncodeGlSampleCoverage(e binary.Encoder, o *GlSampleCoverage) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Invert)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSampleCoverage(d binary.Decoder, o *GlSampleCoverage) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value = GLfloat(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Invert = GLboolean(obj)
	}
	return nil
}
func doSkipGlSampleCoverage(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSampleCoverage) ID() binary.ID      { return binaryIDGlSampleCoverage }
func (*binaryClassGlSampleCoverage) New() binary.Object { return &GlSampleCoverage{} }
func (*binaryClassGlSampleCoverage) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSampleCoverage(e, obj.(*GlSampleCoverage))
}
func (*binaryClassGlSampleCoverage) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSampleCoverage{}
	return obj, doDecodeGlSampleCoverage(d, obj)
}
func (*binaryClassGlSampleCoverage) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSampleCoverage(d, obj.(*GlSampleCoverage))
}
func (*binaryClassGlSampleCoverage) Skip(d binary.Decoder) error { return doSkipGlSampleCoverage(d) }
func (*binaryClassGlSampleCoverage) Schema() *schema.Class       { return schemaGlSampleCoverage }

var schemaGlSampleCoverage = &schema.Class{
	TypeID:  binaryIDGlSampleCoverage,
	Package: "gles",
	Name:    "GlSampleCoverage",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Invert", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlSampleMaski struct{}

func (*GlSampleMaski) Class() binary.Class {
	return (*binaryClassGlSampleMaski)(nil)
}
func doEncodeGlSampleMaski(e binary.Encoder, o *GlSampleMaski) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.MaskNumber)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSampleMaski(d binary.Decoder, o *GlSampleMaski) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MaskNumber = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLbitfield(obj)
	}
	return nil
}
func doSkipGlSampleMaski(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSampleMaski) ID() binary.ID      { return binaryIDGlSampleMaski }
func (*binaryClassGlSampleMaski) New() binary.Object { return &GlSampleMaski{} }
func (*binaryClassGlSampleMaski) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSampleMaski(e, obj.(*GlSampleMaski))
}
func (*binaryClassGlSampleMaski) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSampleMaski{}
	return obj, doDecodeGlSampleMaski(d, obj)
}
func (*binaryClassGlSampleMaski) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSampleMaski(d, obj.(*GlSampleMaski))
}
func (*binaryClassGlSampleMaski) Skip(d binary.Decoder) error { return doSkipGlSampleMaski(d) }
func (*binaryClassGlSampleMaski) Schema() *schema.Class       { return schemaGlSampleMaski }

var schemaGlSampleMaski = &schema.Class{
	TypeID:  binaryIDGlSampleMaski,
	Package: "gles",
	Name:    "GlSampleMaski",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "MaskNumber", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlSamplerParameterIivEXT struct{}

func (*GlSamplerParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIivEXT)(nil)
}
func doEncodeGlSamplerParameterIivEXT(e binary.Encoder, o *GlSamplerParameterIivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterIivEXT(d binary.Decoder, o *GlSamplerParameterIivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameterIivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterIivEXT) ID() binary.ID      { return binaryIDGlSamplerParameterIivEXT }
func (*binaryClassGlSamplerParameterIivEXT) New() binary.Object { return &GlSamplerParameterIivEXT{} }
func (*binaryClassGlSamplerParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterIivEXT(e, obj.(*GlSamplerParameterIivEXT))
}
func (*binaryClassGlSamplerParameterIivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterIivEXT{}
	return obj, doDecodeGlSamplerParameterIivEXT(d, obj)
}
func (*binaryClassGlSamplerParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterIivEXT(d, obj.(*GlSamplerParameterIivEXT))
}
func (*binaryClassGlSamplerParameterIivEXT) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterIivEXT(d)
}
func (*binaryClassGlSamplerParameterIivEXT) Schema() *schema.Class {
	return schemaGlSamplerParameterIivEXT
}

var schemaGlSamplerParameterIivEXT = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterIivEXT,
	Package: "gles",
	Name:    "GlSamplerParameterIivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSamplerParameterIivOES struct{}

func (*GlSamplerParameterIivOES) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIivOES)(nil)
}
func doEncodeGlSamplerParameterIivOES(e binary.Encoder, o *GlSamplerParameterIivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterIivOES(d binary.Decoder, o *GlSamplerParameterIivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameterIivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterIivOES) ID() binary.ID      { return binaryIDGlSamplerParameterIivOES }
func (*binaryClassGlSamplerParameterIivOES) New() binary.Object { return &GlSamplerParameterIivOES{} }
func (*binaryClassGlSamplerParameterIivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterIivOES(e, obj.(*GlSamplerParameterIivOES))
}
func (*binaryClassGlSamplerParameterIivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterIivOES{}
	return obj, doDecodeGlSamplerParameterIivOES(d, obj)
}
func (*binaryClassGlSamplerParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterIivOES(d, obj.(*GlSamplerParameterIivOES))
}
func (*binaryClassGlSamplerParameterIivOES) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterIivOES(d)
}
func (*binaryClassGlSamplerParameterIivOES) Schema() *schema.Class {
	return schemaGlSamplerParameterIivOES
}

var schemaGlSamplerParameterIivOES = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterIivOES,
	Package: "gles",
	Name:    "GlSamplerParameterIivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSamplerParameterIuivEXT struct{}

func (*GlSamplerParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIuivEXT)(nil)
}
func doEncodeGlSamplerParameterIuivEXT(e binary.Encoder, o *GlSamplerParameterIuivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterIuivEXT(d binary.Decoder, o *GlSamplerParameterIuivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameterIuivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterIuivEXT) ID() binary.ID      { return binaryIDGlSamplerParameterIuivEXT }
func (*binaryClassGlSamplerParameterIuivEXT) New() binary.Object { return &GlSamplerParameterIuivEXT{} }
func (*binaryClassGlSamplerParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterIuivEXT(e, obj.(*GlSamplerParameterIuivEXT))
}
func (*binaryClassGlSamplerParameterIuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterIuivEXT{}
	return obj, doDecodeGlSamplerParameterIuivEXT(d, obj)
}
func (*binaryClassGlSamplerParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterIuivEXT(d, obj.(*GlSamplerParameterIuivEXT))
}
func (*binaryClassGlSamplerParameterIuivEXT) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterIuivEXT(d)
}
func (*binaryClassGlSamplerParameterIuivEXT) Schema() *schema.Class {
	return schemaGlSamplerParameterIuivEXT
}

var schemaGlSamplerParameterIuivEXT = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterIuivEXT,
	Package: "gles",
	Name:    "GlSamplerParameterIuivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSamplerParameterIuivOES struct{}

func (*GlSamplerParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlSamplerParameterIuivOES)(nil)
}
func doEncodeGlSamplerParameterIuivOES(e binary.Encoder, o *GlSamplerParameterIuivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterIuivOES(d binary.Decoder, o *GlSamplerParameterIuivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameterIuivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterIuivOES) ID() binary.ID      { return binaryIDGlSamplerParameterIuivOES }
func (*binaryClassGlSamplerParameterIuivOES) New() binary.Object { return &GlSamplerParameterIuivOES{} }
func (*binaryClassGlSamplerParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterIuivOES(e, obj.(*GlSamplerParameterIuivOES))
}
func (*binaryClassGlSamplerParameterIuivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterIuivOES{}
	return obj, doDecodeGlSamplerParameterIuivOES(d, obj)
}
func (*binaryClassGlSamplerParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterIuivOES(d, obj.(*GlSamplerParameterIuivOES))
}
func (*binaryClassGlSamplerParameterIuivOES) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterIuivOES(d)
}
func (*binaryClassGlSamplerParameterIuivOES) Schema() *schema.Class {
	return schemaGlSamplerParameterIuivOES
}

var schemaGlSamplerParameterIuivOES = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterIuivOES,
	Package: "gles",
	Name:    "GlSamplerParameterIuivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSamplerParameterf struct{}

func (*GlSamplerParameterf) Class() binary.Class {
	return (*binaryClassGlSamplerParameterf)(nil)
}
func doEncodeGlSamplerParameterf(e binary.Encoder, o *GlSamplerParameterf) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Param)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterf(d binary.Decoder, o *GlSamplerParameterf) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Param = GLfloat(obj)
	}
	return nil
}
func doSkipGlSamplerParameterf(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterf) ID() binary.ID      { return binaryIDGlSamplerParameterf }
func (*binaryClassGlSamplerParameterf) New() binary.Object { return &GlSamplerParameterf{} }
func (*binaryClassGlSamplerParameterf) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterf(e, obj.(*GlSamplerParameterf))
}
func (*binaryClassGlSamplerParameterf) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterf{}
	return obj, doDecodeGlSamplerParameterf(d, obj)
}
func (*binaryClassGlSamplerParameterf) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterf(d, obj.(*GlSamplerParameterf))
}
func (*binaryClassGlSamplerParameterf) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterf(d)
}
func (*binaryClassGlSamplerParameterf) Schema() *schema.Class { return schemaGlSamplerParameterf }

var schemaGlSamplerParameterf = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterf,
	Package: "gles",
	Name:    "GlSamplerParameterf",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlSamplerParameterfv struct{}

func (*GlSamplerParameterfv) Class() binary.Class {
	return (*binaryClassGlSamplerParameterfv)(nil)
}
func doEncodeGlSamplerParameterfv(e binary.Encoder, o *GlSamplerParameterfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameterfv(d binary.Decoder, o *GlSamplerParameterfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameterfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameterfv) ID() binary.ID      { return binaryIDGlSamplerParameterfv }
func (*binaryClassGlSamplerParameterfv) New() binary.Object { return &GlSamplerParameterfv{} }
func (*binaryClassGlSamplerParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameterfv(e, obj.(*GlSamplerParameterfv))
}
func (*binaryClassGlSamplerParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameterfv{}
	return obj, doDecodeGlSamplerParameterfv(d, obj)
}
func (*binaryClassGlSamplerParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameterfv(d, obj.(*GlSamplerParameterfv))
}
func (*binaryClassGlSamplerParameterfv) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameterfv(d)
}
func (*binaryClassGlSamplerParameterfv) Schema() *schema.Class { return schemaGlSamplerParameterfv }

var schemaGlSamplerParameterfv = &schema.Class{
	TypeID:  binaryIDGlSamplerParameterfv,
	Package: "gles",
	Name:    "GlSamplerParameterfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSamplerParameteri struct{}

func (*GlSamplerParameteri) Class() binary.Class {
	return (*binaryClassGlSamplerParameteri)(nil)
}
func doEncodeGlSamplerParameteri(e binary.Encoder, o *GlSamplerParameteri) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Param)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameteri(d binary.Decoder, o *GlSamplerParameteri) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Param = GLint(obj)
	}
	return nil
}
func doSkipGlSamplerParameteri(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameteri) ID() binary.ID      { return binaryIDGlSamplerParameteri }
func (*binaryClassGlSamplerParameteri) New() binary.Object { return &GlSamplerParameteri{} }
func (*binaryClassGlSamplerParameteri) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameteri(e, obj.(*GlSamplerParameteri))
}
func (*binaryClassGlSamplerParameteri) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameteri{}
	return obj, doDecodeGlSamplerParameteri(d, obj)
}
func (*binaryClassGlSamplerParameteri) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameteri(d, obj.(*GlSamplerParameteri))
}
func (*binaryClassGlSamplerParameteri) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameteri(d)
}
func (*binaryClassGlSamplerParameteri) Schema() *schema.Class { return schemaGlSamplerParameteri }

var schemaGlSamplerParameteri = &schema.Class{
	TypeID:  binaryIDGlSamplerParameteri,
	Package: "gles",
	Name:    "GlSamplerParameteri",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlSamplerParameteriv struct{}

func (*GlSamplerParameteriv) Class() binary.Class {
	return (*binaryClassGlSamplerParameteriv)(nil)
}
func doEncodeGlSamplerParameteriv(e binary.Encoder, o *GlSamplerParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Sampler)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSamplerParameteriv(d binary.Decoder, o *GlSamplerParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Sampler = SamplerId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Param); err != nil {
		return err
	}
	return nil
}
func doSkipGlSamplerParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSamplerParameteriv) ID() binary.ID      { return binaryIDGlSamplerParameteriv }
func (*binaryClassGlSamplerParameteriv) New() binary.Object { return &GlSamplerParameteriv{} }
func (*binaryClassGlSamplerParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSamplerParameteriv(e, obj.(*GlSamplerParameteriv))
}
func (*binaryClassGlSamplerParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSamplerParameteriv{}
	return obj, doDecodeGlSamplerParameteriv(d, obj)
}
func (*binaryClassGlSamplerParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSamplerParameteriv(d, obj.(*GlSamplerParameteriv))
}
func (*binaryClassGlSamplerParameteriv) Skip(d binary.Decoder) error {
	return doSkipGlSamplerParameteriv(d)
}
func (*binaryClassGlSamplerParameteriv) Schema() *schema.Class { return schemaGlSamplerParameteriv }

var schemaGlSamplerParameteriv = &schema.Class{
	TypeID:  binaryIDGlSamplerParameteriv,
	Package: "gles",
	Name:    "GlSamplerParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Param", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlScissor struct{}

func (*GlScissor) Class() binary.Class {
	return (*binaryClassGlScissor)(nil)
}
func doEncodeGlScissor(e binary.Encoder, o *GlScissor) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlScissor(d binary.Decoder, o *GlScissor) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlScissor(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlScissor) ID() binary.ID      { return binaryIDGlScissor }
func (*binaryClassGlScissor) New() binary.Object { return &GlScissor{} }
func (*binaryClassGlScissor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlScissor(e, obj.(*GlScissor))
}
func (*binaryClassGlScissor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlScissor{}
	return obj, doDecodeGlScissor(d, obj)
}
func (*binaryClassGlScissor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlScissor(d, obj.(*GlScissor))
}
func (*binaryClassGlScissor) Skip(d binary.Decoder) error { return doSkipGlScissor(d) }
func (*binaryClassGlScissor) Schema() *schema.Class       { return schemaGlScissor }

var schemaGlScissor = &schema.Class{
	TypeID:  binaryIDGlScissor,
	Package: "gles",
	Name:    "GlScissor",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlScissorArrayvNV struct{}

func (*GlScissorArrayvNV) Class() binary.Class {
	return (*binaryClassGlScissorArrayvNV)(nil)
}
func doEncodeGlScissorArrayvNV(e binary.Encoder, o *GlScissorArrayvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlScissorArrayvNV(d binary.Decoder, o *GlScissorArrayvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.First = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlScissorArrayvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlScissorArrayvNV) ID() binary.ID      { return binaryIDGlScissorArrayvNV }
func (*binaryClassGlScissorArrayvNV) New() binary.Object { return &GlScissorArrayvNV{} }
func (*binaryClassGlScissorArrayvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlScissorArrayvNV(e, obj.(*GlScissorArrayvNV))
}
func (*binaryClassGlScissorArrayvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlScissorArrayvNV{}
	return obj, doDecodeGlScissorArrayvNV(d, obj)
}
func (*binaryClassGlScissorArrayvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlScissorArrayvNV(d, obj.(*GlScissorArrayvNV))
}
func (*binaryClassGlScissorArrayvNV) Skip(d binary.Decoder) error { return doSkipGlScissorArrayvNV(d) }
func (*binaryClassGlScissorArrayvNV) Schema() *schema.Class       { return schemaGlScissorArrayvNV }

var schemaGlScissorArrayvNV = &schema.Class{
	TypeID:  binaryIDGlScissorArrayvNV,
	Package: "gles",
	Name:    "GlScissorArrayvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlScissorIndexedNV struct{}

func (*GlScissorIndexedNV) Class() binary.Class {
	return (*binaryClassGlScissorIndexedNV)(nil)
}
func doEncodeGlScissorIndexedNV(e binary.Encoder, o *GlScissorIndexedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Left)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Bottom)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlScissorIndexedNV(d binary.Decoder, o *GlScissorIndexedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Left = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Bottom = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlScissorIndexedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlScissorIndexedNV) ID() binary.ID      { return binaryIDGlScissorIndexedNV }
func (*binaryClassGlScissorIndexedNV) New() binary.Object { return &GlScissorIndexedNV{} }
func (*binaryClassGlScissorIndexedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlScissorIndexedNV(e, obj.(*GlScissorIndexedNV))
}
func (*binaryClassGlScissorIndexedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlScissorIndexedNV{}
	return obj, doDecodeGlScissorIndexedNV(d, obj)
}
func (*binaryClassGlScissorIndexedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlScissorIndexedNV(d, obj.(*GlScissorIndexedNV))
}
func (*binaryClassGlScissorIndexedNV) Skip(d binary.Decoder) error { return doSkipGlScissorIndexedNV(d) }
func (*binaryClassGlScissorIndexedNV) Schema() *schema.Class       { return schemaGlScissorIndexedNV }

var schemaGlScissorIndexedNV = &schema.Class{
	TypeID:  binaryIDGlScissorIndexedNV,
	Package: "gles",
	Name:    "GlScissorIndexedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Left", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Bottom", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlScissorIndexedvNV struct{}

func (*GlScissorIndexedvNV) Class() binary.Class {
	return (*binaryClassGlScissorIndexedvNV)(nil)
}
func doEncodeGlScissorIndexedvNV(e binary.Encoder, o *GlScissorIndexedvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlScissorIndexedvNV(d binary.Decoder, o *GlScissorIndexedvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlScissorIndexedvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlScissorIndexedvNV) ID() binary.ID      { return binaryIDGlScissorIndexedvNV }
func (*binaryClassGlScissorIndexedvNV) New() binary.Object { return &GlScissorIndexedvNV{} }
func (*binaryClassGlScissorIndexedvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlScissorIndexedvNV(e, obj.(*GlScissorIndexedvNV))
}
func (*binaryClassGlScissorIndexedvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlScissorIndexedvNV{}
	return obj, doDecodeGlScissorIndexedvNV(d, obj)
}
func (*binaryClassGlScissorIndexedvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlScissorIndexedvNV(d, obj.(*GlScissorIndexedvNV))
}
func (*binaryClassGlScissorIndexedvNV) Skip(d binary.Decoder) error {
	return doSkipGlScissorIndexedvNV(d)
}
func (*binaryClassGlScissorIndexedvNV) Schema() *schema.Class { return schemaGlScissorIndexedvNV }

var schemaGlScissorIndexedvNV = &schema.Class{
	TypeID:  binaryIDGlScissorIndexedvNV,
	Package: "gles",
	Name:    "GlScissorIndexedvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSelectPerfMonitorCountersAMD struct{}

func (*GlSelectPerfMonitorCountersAMD) Class() binary.Class {
	return (*binaryClassGlSelectPerfMonitorCountersAMD)(nil)
}
func doEncodeGlSelectPerfMonitorCountersAMD(e binary.Encoder, o *GlSelectPerfMonitorCountersAMD) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Monitor)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Enable)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Group)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumCounters)); err != nil {
		return err
	}
	if err := e.Value(&o.CounterList); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSelectPerfMonitorCountersAMD(d binary.Decoder, o *GlSelectPerfMonitorCountersAMD) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Monitor = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Enable = GLboolean(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Group = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumCounters = GLint(obj)
	}
	if err := d.Value(&o.CounterList); err != nil {
		return err
	}
	return nil
}
func doSkipGlSelectPerfMonitorCountersAMD(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) ID() binary.ID {
	return binaryIDGlSelectPerfMonitorCountersAMD
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) New() binary.Object {
	return &GlSelectPerfMonitorCountersAMD{}
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSelectPerfMonitorCountersAMD(e, obj.(*GlSelectPerfMonitorCountersAMD))
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSelectPerfMonitorCountersAMD{}
	return obj, doDecodeGlSelectPerfMonitorCountersAMD(d, obj)
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSelectPerfMonitorCountersAMD(d, obj.(*GlSelectPerfMonitorCountersAMD))
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) Skip(d binary.Decoder) error {
	return doSkipGlSelectPerfMonitorCountersAMD(d)
}
func (*binaryClassGlSelectPerfMonitorCountersAMD) Schema() *schema.Class {
	return schemaGlSelectPerfMonitorCountersAMD
}

var schemaGlSelectPerfMonitorCountersAMD = &schema.Class{
	TypeID:  binaryIDGlSelectPerfMonitorCountersAMD,
	Package: "gles",
	Name:    "GlSelectPerfMonitorCountersAMD",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Monitor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Enable", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Group", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumCounters", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "CounterList", Type: &schema.Struct{Name: "GLuintᵖ", ID: (*GLuintᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlSetFenceNV struct{}

func (*GlSetFenceNV) Class() binary.Class {
	return (*binaryClassGlSetFenceNV)(nil)
}
func doEncodeGlSetFenceNV(e binary.Encoder, o *GlSetFenceNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fence)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Condition)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSetFenceNV(d binary.Decoder, o *GlSetFenceNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fence = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Condition = GLenum(obj)
	}
	return nil
}
func doSkipGlSetFenceNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSetFenceNV) ID() binary.ID      { return binaryIDGlSetFenceNV }
func (*binaryClassGlSetFenceNV) New() binary.Object { return &GlSetFenceNV{} }
func (*binaryClassGlSetFenceNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSetFenceNV(e, obj.(*GlSetFenceNV))
}
func (*binaryClassGlSetFenceNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSetFenceNV{}
	return obj, doDecodeGlSetFenceNV(d, obj)
}
func (*binaryClassGlSetFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSetFenceNV(d, obj.(*GlSetFenceNV))
}
func (*binaryClassGlSetFenceNV) Skip(d binary.Decoder) error { return doSkipGlSetFenceNV(d) }
func (*binaryClassGlSetFenceNV) Schema() *schema.Class       { return schemaGlSetFenceNV }

var schemaGlSetFenceNV = &schema.Class{
	TypeID:  binaryIDGlSetFenceNV,
	Package: "gles",
	Name:    "GlSetFenceNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Condition", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassShaderIdᶜᵖ struct{}

func (*ShaderIdᶜᵖ) Class() binary.Class {
	return (*binaryClassShaderIdᶜᵖ)(nil)
}
func doEncodeShaderIdᶜᵖ(e binary.Encoder, o *ShaderIdᶜᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeShaderIdᶜᵖ(d binary.Decoder, o *ShaderIdᶜᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipShaderIdᶜᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassShaderIdᶜᵖ) ID() binary.ID      { return binaryIDShaderIdᶜᵖ }
func (*binaryClassShaderIdᶜᵖ) New() binary.Object { return &ShaderIdᶜᵖ{} }
func (*binaryClassShaderIdᶜᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeShaderIdᶜᵖ(e, obj.(*ShaderIdᶜᵖ))
}
func (*binaryClassShaderIdᶜᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ShaderIdᶜᵖ{}
	return obj, doDecodeShaderIdᶜᵖ(d, obj)
}
func (*binaryClassShaderIdᶜᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeShaderIdᶜᵖ(d, obj.(*ShaderIdᶜᵖ))
}
func (*binaryClassShaderIdᶜᵖ) Skip(d binary.Decoder) error { return doSkipShaderIdᶜᵖ(d) }
func (*binaryClassShaderIdᶜᵖ) Schema() *schema.Class       { return schemaShaderIdᶜᵖ }

var schemaShaderIdᶜᵖ = &schema.Class{
	TypeID:  binaryIDShaderIdᶜᵖ,
	Package: "gles",
	Name:    "ShaderIdᶜᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlShaderBinary struct{}

func (*GlShaderBinary) Class() binary.Class {
	return (*binaryClassGlShaderBinary)(nil)
}
func doEncodeGlShaderBinary(e binary.Encoder, o *GlShaderBinary) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Shaders); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BinaryFormat)); err != nil {
		return err
	}
	if err := e.Value(&o.Binary); err != nil {
		return err
	}
	if err := e.Int32(int32(o.BinarySize)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlShaderBinary(d binary.Decoder, o *GlShaderBinary) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Shaders); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BinaryFormat = GLenum(obj)
	}
	if err := d.Value(&o.Binary); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.BinarySize = GLsizei(obj)
	}
	return nil
}
func doSkipGlShaderBinary(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*ShaderIdᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlShaderBinary) ID() binary.ID      { return binaryIDGlShaderBinary }
func (*binaryClassGlShaderBinary) New() binary.Object { return &GlShaderBinary{} }
func (*binaryClassGlShaderBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlShaderBinary(e, obj.(*GlShaderBinary))
}
func (*binaryClassGlShaderBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlShaderBinary{}
	return obj, doDecodeGlShaderBinary(d, obj)
}
func (*binaryClassGlShaderBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlShaderBinary(d, obj.(*GlShaderBinary))
}
func (*binaryClassGlShaderBinary) Skip(d binary.Decoder) error { return doSkipGlShaderBinary(d) }
func (*binaryClassGlShaderBinary) Schema() *schema.Class       { return schemaGlShaderBinary }

var schemaGlShaderBinary = &schema.Class{
	TypeID:  binaryIDGlShaderBinary,
	Package: "gles",
	Name:    "GlShaderBinary",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Shaders", Type: &schema.Struct{Name: "ShaderIdᶜᵖ", ID: (*ShaderIdᶜᵖ)(nil).Class().ID()}},
		{Declared: "BinaryFormat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Binary", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "BinarySize", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlShaderSource struct{}

func (*GlShaderSource) Class() binary.Class {
	return (*binaryClassGlShaderSource)(nil)
}
func doEncodeGlShaderSource(e binary.Encoder, o *GlShaderSource) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Shader)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Source); err != nil {
		return err
	}
	if err := e.Value(&o.Length); err != nil {
		return err
	}
	return nil
}
func doDecodeGlShaderSource(d binary.Decoder, o *GlShaderSource) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Shader = ShaderId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Source); err != nil {
		return err
	}
	if err := d.Value(&o.Length); err != nil {
		return err
	}
	return nil
}
func doSkipGlShaderSource(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlShaderSource) ID() binary.ID      { return binaryIDGlShaderSource }
func (*binaryClassGlShaderSource) New() binary.Object { return &GlShaderSource{} }
func (*binaryClassGlShaderSource) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlShaderSource(e, obj.(*GlShaderSource))
}
func (*binaryClassGlShaderSource) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlShaderSource{}
	return obj, doDecodeGlShaderSource(d, obj)
}
func (*binaryClassGlShaderSource) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlShaderSource(d, obj.(*GlShaderSource))
}
func (*binaryClassGlShaderSource) Skip(d binary.Decoder) error { return doSkipGlShaderSource(d) }
func (*binaryClassGlShaderSource) Schema() *schema.Class       { return schemaGlShaderSource }

var schemaGlShaderSource = &schema.Class{
	TypeID:  binaryIDGlShaderSource,
	Package: "gles",
	Name:    "GlShaderSource",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Source", Type: &schema.Struct{Name: "GLcharᶜᵖᶜᵖ", ID: (*GLcharᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "Length", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlStartTilingQCOM struct{}

func (*GlStartTilingQCOM) Class() binary.Class {
	return (*binaryClassGlStartTilingQCOM)(nil)
}
func doEncodeGlStartTilingQCOM(e binary.Encoder, o *GlStartTilingQCOM) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.X)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Y)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Width)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PreserveMask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStartTilingQCOM(d binary.Decoder, o *GlStartTilingQCOM) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.X = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Y = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PreserveMask = GLbitfield(obj)
	}
	return nil
}
func doSkipGlStartTilingQCOM(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStartTilingQCOM) ID() binary.ID      { return binaryIDGlStartTilingQCOM }
func (*binaryClassGlStartTilingQCOM) New() binary.Object { return &GlStartTilingQCOM{} }
func (*binaryClassGlStartTilingQCOM) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStartTilingQCOM(e, obj.(*GlStartTilingQCOM))
}
func (*binaryClassGlStartTilingQCOM) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStartTilingQCOM{}
	return obj, doDecodeGlStartTilingQCOM(d, obj)
}
func (*binaryClassGlStartTilingQCOM) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStartTilingQCOM(d, obj.(*GlStartTilingQCOM))
}
func (*binaryClassGlStartTilingQCOM) Skip(d binary.Decoder) error { return doSkipGlStartTilingQCOM(d) }
func (*binaryClassGlStartTilingQCOM) Schema() *schema.Class       { return schemaGlStartTilingQCOM }

var schemaGlStartTilingQCOM = &schema.Class{
	TypeID:  binaryIDGlStartTilingQCOM,
	Package: "gles",
	Name:    "GlStartTilingQCOM",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "PreserveMask", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilFillPathInstancedNV struct{}

func (*GlStencilFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilFillPathInstancedNV)(nil)
}
func doEncodeGlStencilFillPathInstancedNV(e binary.Encoder, o *GlStencilFillPathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FillMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilFillPathInstancedNV(d binary.Decoder, o *GlStencilFillPathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FillMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlStencilFillPathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilFillPathInstancedNV) ID() binary.ID {
	return binaryIDGlStencilFillPathInstancedNV
}
func (*binaryClassGlStencilFillPathInstancedNV) New() binary.Object {
	return &GlStencilFillPathInstancedNV{}
}
func (*binaryClassGlStencilFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilFillPathInstancedNV(e, obj.(*GlStencilFillPathInstancedNV))
}
func (*binaryClassGlStencilFillPathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilFillPathInstancedNV{}
	return obj, doDecodeGlStencilFillPathInstancedNV(d, obj)
}
func (*binaryClassGlStencilFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilFillPathInstancedNV(d, obj.(*GlStencilFillPathInstancedNV))
}
func (*binaryClassGlStencilFillPathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilFillPathInstancedNV(d)
}
func (*binaryClassGlStencilFillPathInstancedNV) Schema() *schema.Class {
	return schemaGlStencilFillPathInstancedNV
}

var schemaGlStencilFillPathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlStencilFillPathInstancedNV,
	Package: "gles",
	Name:    "GlStencilFillPathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FillMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlStencilFillPathNV struct{}

func (*GlStencilFillPathNV) Class() binary.Class {
	return (*binaryClassGlStencilFillPathNV)(nil)
}
func doEncodeGlStencilFillPathNV(e binary.Encoder, o *GlStencilFillPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FillMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilFillPathNV(d binary.Decoder, o *GlStencilFillPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FillMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilFillPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilFillPathNV) ID() binary.ID      { return binaryIDGlStencilFillPathNV }
func (*binaryClassGlStencilFillPathNV) New() binary.Object { return &GlStencilFillPathNV{} }
func (*binaryClassGlStencilFillPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilFillPathNV(e, obj.(*GlStencilFillPathNV))
}
func (*binaryClassGlStencilFillPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilFillPathNV{}
	return obj, doDecodeGlStencilFillPathNV(d, obj)
}
func (*binaryClassGlStencilFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilFillPathNV(d, obj.(*GlStencilFillPathNV))
}
func (*binaryClassGlStencilFillPathNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilFillPathNV(d)
}
func (*binaryClassGlStencilFillPathNV) Schema() *schema.Class { return schemaGlStencilFillPathNV }

var schemaGlStencilFillPathNV = &schema.Class{
	TypeID:  binaryIDGlStencilFillPathNV,
	Package: "gles",
	Name:    "GlStencilFillPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FillMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilFunc struct{}

func (*GlStencilFunc) Class() binary.Class {
	return (*binaryClassGlStencilFunc)(nil)
}
func doEncodeGlStencilFunc(e binary.Encoder, o *GlStencilFunc) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Func)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Ref)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilFunc(d binary.Decoder, o *GlStencilFunc) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Func = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Ref = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilFunc(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilFunc) ID() binary.ID      { return binaryIDGlStencilFunc }
func (*binaryClassGlStencilFunc) New() binary.Object { return &GlStencilFunc{} }
func (*binaryClassGlStencilFunc) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilFunc(e, obj.(*GlStencilFunc))
}
func (*binaryClassGlStencilFunc) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilFunc{}
	return obj, doDecodeGlStencilFunc(d, obj)
}
func (*binaryClassGlStencilFunc) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilFunc(d, obj.(*GlStencilFunc))
}
func (*binaryClassGlStencilFunc) Skip(d binary.Decoder) error { return doSkipGlStencilFunc(d) }
func (*binaryClassGlStencilFunc) Schema() *schema.Class       { return schemaGlStencilFunc }

var schemaGlStencilFunc = &schema.Class{
	TypeID:  binaryIDGlStencilFunc,
	Package: "gles",
	Name:    "GlStencilFunc",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Func", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Ref", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilFuncSeparate struct{}

func (*GlStencilFuncSeparate) Class() binary.Class {
	return (*binaryClassGlStencilFuncSeparate)(nil)
}
func doEncodeGlStencilFuncSeparate(e binary.Encoder, o *GlStencilFuncSeparate) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Face)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Function)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.ReferenceValue)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilFuncSeparate(d binary.Decoder, o *GlStencilFuncSeparate) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Face = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Function = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.ReferenceValue = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilFuncSeparate(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilFuncSeparate) ID() binary.ID      { return binaryIDGlStencilFuncSeparate }
func (*binaryClassGlStencilFuncSeparate) New() binary.Object { return &GlStencilFuncSeparate{} }
func (*binaryClassGlStencilFuncSeparate) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilFuncSeparate(e, obj.(*GlStencilFuncSeparate))
}
func (*binaryClassGlStencilFuncSeparate) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilFuncSeparate{}
	return obj, doDecodeGlStencilFuncSeparate(d, obj)
}
func (*binaryClassGlStencilFuncSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilFuncSeparate(d, obj.(*GlStencilFuncSeparate))
}
func (*binaryClassGlStencilFuncSeparate) Skip(d binary.Decoder) error {
	return doSkipGlStencilFuncSeparate(d)
}
func (*binaryClassGlStencilFuncSeparate) Schema() *schema.Class { return schemaGlStencilFuncSeparate }

var schemaGlStencilFuncSeparate = &schema.Class{
	TypeID:  binaryIDGlStencilFuncSeparate,
	Package: "gles",
	Name:    "GlStencilFuncSeparate",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Face", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Function", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "ReferenceValue", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilMask struct{}

func (*GlStencilMask) Class() binary.Class {
	return (*binaryClassGlStencilMask)(nil)
}
func doEncodeGlStencilMask(e binary.Encoder, o *GlStencilMask) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilMask(d binary.Decoder, o *GlStencilMask) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilMask(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilMask) ID() binary.ID      { return binaryIDGlStencilMask }
func (*binaryClassGlStencilMask) New() binary.Object { return &GlStencilMask{} }
func (*binaryClassGlStencilMask) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilMask(e, obj.(*GlStencilMask))
}
func (*binaryClassGlStencilMask) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilMask{}
	return obj, doDecodeGlStencilMask(d, obj)
}
func (*binaryClassGlStencilMask) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilMask(d, obj.(*GlStencilMask))
}
func (*binaryClassGlStencilMask) Skip(d binary.Decoder) error { return doSkipGlStencilMask(d) }
func (*binaryClassGlStencilMask) Schema() *schema.Class       { return schemaGlStencilMask }

var schemaGlStencilMask = &schema.Class{
	TypeID:  binaryIDGlStencilMask,
	Package: "gles",
	Name:    "GlStencilMask",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilMaskSeparate struct{}

func (*GlStencilMaskSeparate) Class() binary.Class {
	return (*binaryClassGlStencilMaskSeparate)(nil)
}
func doEncodeGlStencilMaskSeparate(e binary.Encoder, o *GlStencilMaskSeparate) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Face)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilMaskSeparate(d binary.Decoder, o *GlStencilMaskSeparate) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Face = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilMaskSeparate(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilMaskSeparate) ID() binary.ID      { return binaryIDGlStencilMaskSeparate }
func (*binaryClassGlStencilMaskSeparate) New() binary.Object { return &GlStencilMaskSeparate{} }
func (*binaryClassGlStencilMaskSeparate) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilMaskSeparate(e, obj.(*GlStencilMaskSeparate))
}
func (*binaryClassGlStencilMaskSeparate) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilMaskSeparate{}
	return obj, doDecodeGlStencilMaskSeparate(d, obj)
}
func (*binaryClassGlStencilMaskSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilMaskSeparate(d, obj.(*GlStencilMaskSeparate))
}
func (*binaryClassGlStencilMaskSeparate) Skip(d binary.Decoder) error {
	return doSkipGlStencilMaskSeparate(d)
}
func (*binaryClassGlStencilMaskSeparate) Schema() *schema.Class { return schemaGlStencilMaskSeparate }

var schemaGlStencilMaskSeparate = &schema.Class{
	TypeID:  binaryIDGlStencilMaskSeparate,
	Package: "gles",
	Name:    "GlStencilMaskSeparate",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Face", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilOp struct{}

func (*GlStencilOp) Class() binary.Class {
	return (*binaryClassGlStencilOp)(nil)
}
func doEncodeGlStencilOp(e binary.Encoder, o *GlStencilOp) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fail)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Zfail)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Zpass)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilOp(d binary.Decoder, o *GlStencilOp) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fail = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Zfail = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Zpass = GLenum(obj)
	}
	return nil
}
func doSkipGlStencilOp(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilOp) ID() binary.ID      { return binaryIDGlStencilOp }
func (*binaryClassGlStencilOp) New() binary.Object { return &GlStencilOp{} }
func (*binaryClassGlStencilOp) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilOp(e, obj.(*GlStencilOp))
}
func (*binaryClassGlStencilOp) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilOp{}
	return obj, doDecodeGlStencilOp(d, obj)
}
func (*binaryClassGlStencilOp) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilOp(d, obj.(*GlStencilOp))
}
func (*binaryClassGlStencilOp) Skip(d binary.Decoder) error { return doSkipGlStencilOp(d) }
func (*binaryClassGlStencilOp) Schema() *schema.Class       { return schemaGlStencilOp }

var schemaGlStencilOp = &schema.Class{
	TypeID:  binaryIDGlStencilOp,
	Package: "gles",
	Name:    "GlStencilOp",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fail", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Zfail", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Zpass", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilOpSeparate struct{}

func (*GlStencilOpSeparate) Class() binary.Class {
	return (*binaryClassGlStencilOpSeparate)(nil)
}
func doEncodeGlStencilOpSeparate(e binary.Encoder, o *GlStencilOpSeparate) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Face)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.StencilFail)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.StencilPassDepthFail)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.StencilPassDepthPass)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilOpSeparate(d binary.Decoder, o *GlStencilOpSeparate) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Face = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.StencilFail = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.StencilPassDepthFail = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.StencilPassDepthPass = GLenum(obj)
	}
	return nil
}
func doSkipGlStencilOpSeparate(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilOpSeparate) ID() binary.ID      { return binaryIDGlStencilOpSeparate }
func (*binaryClassGlStencilOpSeparate) New() binary.Object { return &GlStencilOpSeparate{} }
func (*binaryClassGlStencilOpSeparate) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilOpSeparate(e, obj.(*GlStencilOpSeparate))
}
func (*binaryClassGlStencilOpSeparate) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilOpSeparate{}
	return obj, doDecodeGlStencilOpSeparate(d, obj)
}
func (*binaryClassGlStencilOpSeparate) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilOpSeparate(d, obj.(*GlStencilOpSeparate))
}
func (*binaryClassGlStencilOpSeparate) Skip(d binary.Decoder) error {
	return doSkipGlStencilOpSeparate(d)
}
func (*binaryClassGlStencilOpSeparate) Schema() *schema.Class { return schemaGlStencilOpSeparate }

var schemaGlStencilOpSeparate = &schema.Class{
	TypeID:  binaryIDGlStencilOpSeparate,
	Package: "gles",
	Name:    "GlStencilOpSeparate",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Face", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "StencilFail", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "StencilPassDepthFail", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "StencilPassDepthPass", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilStrokePathInstancedNV struct{}

func (*GlStencilStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilStrokePathInstancedNV)(nil)
}
func doEncodeGlStencilStrokePathInstancedNV(e binary.Encoder, o *GlStencilStrokePathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Reference)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilStrokePathInstancedNV(d binary.Decoder, o *GlStencilStrokePathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Reference = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlStencilStrokePathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilStrokePathInstancedNV) ID() binary.ID {
	return binaryIDGlStencilStrokePathInstancedNV
}
func (*binaryClassGlStencilStrokePathInstancedNV) New() binary.Object {
	return &GlStencilStrokePathInstancedNV{}
}
func (*binaryClassGlStencilStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilStrokePathInstancedNV(e, obj.(*GlStencilStrokePathInstancedNV))
}
func (*binaryClassGlStencilStrokePathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilStrokePathInstancedNV{}
	return obj, doDecodeGlStencilStrokePathInstancedNV(d, obj)
}
func (*binaryClassGlStencilStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilStrokePathInstancedNV(d, obj.(*GlStencilStrokePathInstancedNV))
}
func (*binaryClassGlStencilStrokePathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilStrokePathInstancedNV(d)
}
func (*binaryClassGlStencilStrokePathInstancedNV) Schema() *schema.Class {
	return schemaGlStencilStrokePathInstancedNV
}

var schemaGlStencilStrokePathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlStencilStrokePathInstancedNV,
	Package: "gles",
	Name:    "GlStencilStrokePathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Reference", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlStencilStrokePathNV struct{}

func (*GlStencilStrokePathNV) Class() binary.Class {
	return (*binaryClassGlStencilStrokePathNV)(nil)
}
func doEncodeGlStencilStrokePathNV(e binary.Encoder, o *GlStencilStrokePathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Reference)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilStrokePathNV(d binary.Decoder, o *GlStencilStrokePathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Reference = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	return nil
}
func doSkipGlStencilStrokePathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilStrokePathNV) ID() binary.ID      { return binaryIDGlStencilStrokePathNV }
func (*binaryClassGlStencilStrokePathNV) New() binary.Object { return &GlStencilStrokePathNV{} }
func (*binaryClassGlStencilStrokePathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilStrokePathNV(e, obj.(*GlStencilStrokePathNV))
}
func (*binaryClassGlStencilStrokePathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilStrokePathNV{}
	return obj, doDecodeGlStencilStrokePathNV(d, obj)
}
func (*binaryClassGlStencilStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilStrokePathNV(d, obj.(*GlStencilStrokePathNV))
}
func (*binaryClassGlStencilStrokePathNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilStrokePathNV(d)
}
func (*binaryClassGlStencilStrokePathNV) Schema() *schema.Class { return schemaGlStencilStrokePathNV }

var schemaGlStencilStrokePathNV = &schema.Class{
	TypeID:  binaryIDGlStencilStrokePathNV,
	Package: "gles",
	Name:    "GlStencilStrokePathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Reference", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilThenCoverFillPathInstancedNV struct{}

func (*GlStencilThenCoverFillPathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverFillPathInstancedNV)(nil)
}
func doEncodeGlStencilThenCoverFillPathInstancedNV(e binary.Encoder, o *GlStencilThenCoverFillPathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FillMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilThenCoverFillPathInstancedNV(d binary.Decoder, o *GlStencilThenCoverFillPathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FillMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlStencilThenCoverFillPathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) ID() binary.ID {
	return binaryIDGlStencilThenCoverFillPathInstancedNV
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) New() binary.Object {
	return &GlStencilThenCoverFillPathInstancedNV{}
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilThenCoverFillPathInstancedNV(e, obj.(*GlStencilThenCoverFillPathInstancedNV))
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilThenCoverFillPathInstancedNV{}
	return obj, doDecodeGlStencilThenCoverFillPathInstancedNV(d, obj)
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilThenCoverFillPathInstancedNV(d, obj.(*GlStencilThenCoverFillPathInstancedNV))
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilThenCoverFillPathInstancedNV(d)
}
func (*binaryClassGlStencilThenCoverFillPathInstancedNV) Schema() *schema.Class {
	return schemaGlStencilThenCoverFillPathInstancedNV
}

var schemaGlStencilThenCoverFillPathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlStencilThenCoverFillPathInstancedNV,
	Package: "gles",
	Name:    "GlStencilThenCoverFillPathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FillMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlStencilThenCoverFillPathNV struct{}

func (*GlStencilThenCoverFillPathNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverFillPathNV)(nil)
}
func doEncodeGlStencilThenCoverFillPathNV(e binary.Encoder, o *GlStencilThenCoverFillPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.FillMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilThenCoverFillPathNV(d binary.Decoder, o *GlStencilThenCoverFillPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.FillMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	return nil
}
func doSkipGlStencilThenCoverFillPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilThenCoverFillPathNV) ID() binary.ID {
	return binaryIDGlStencilThenCoverFillPathNV
}
func (*binaryClassGlStencilThenCoverFillPathNV) New() binary.Object {
	return &GlStencilThenCoverFillPathNV{}
}
func (*binaryClassGlStencilThenCoverFillPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilThenCoverFillPathNV(e, obj.(*GlStencilThenCoverFillPathNV))
}
func (*binaryClassGlStencilThenCoverFillPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilThenCoverFillPathNV{}
	return obj, doDecodeGlStencilThenCoverFillPathNV(d, obj)
}
func (*binaryClassGlStencilThenCoverFillPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilThenCoverFillPathNV(d, obj.(*GlStencilThenCoverFillPathNV))
}
func (*binaryClassGlStencilThenCoverFillPathNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilThenCoverFillPathNV(d)
}
func (*binaryClassGlStencilThenCoverFillPathNV) Schema() *schema.Class {
	return schemaGlStencilThenCoverFillPathNV
}

var schemaGlStencilThenCoverFillPathNV = &schema.Class{
	TypeID:  binaryIDGlStencilThenCoverFillPathNV,
	Package: "gles",
	Name:    "GlStencilThenCoverFillPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "FillMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlStencilThenCoverStrokePathInstancedNV struct{}

func (*GlStencilThenCoverStrokePathInstancedNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverStrokePathInstancedNV)(nil)
}
func doEncodeGlStencilThenCoverStrokePathInstancedNV(e binary.Encoder, o *GlStencilThenCoverStrokePathInstancedNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathNameType)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.PathBase)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Reference)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilThenCoverStrokePathInstancedNV(d binary.Decoder, o *GlStencilThenCoverStrokePathInstancedNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathNameType = GLenum(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PathBase = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Reference = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlStencilThenCoverStrokePathInstancedNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) ID() binary.ID {
	return binaryIDGlStencilThenCoverStrokePathInstancedNV
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) New() binary.Object {
	return &GlStencilThenCoverStrokePathInstancedNV{}
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilThenCoverStrokePathInstancedNV(e, obj.(*GlStencilThenCoverStrokePathInstancedNV))
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilThenCoverStrokePathInstancedNV{}
	return obj, doDecodeGlStencilThenCoverStrokePathInstancedNV(d, obj)
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilThenCoverStrokePathInstancedNV(d, obj.(*GlStencilThenCoverStrokePathInstancedNV))
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilThenCoverStrokePathInstancedNV(d)
}
func (*binaryClassGlStencilThenCoverStrokePathInstancedNV) Schema() *schema.Class {
	return schemaGlStencilThenCoverStrokePathInstancedNV
}

var schemaGlStencilThenCoverStrokePathInstancedNV = &schema.Class{
	TypeID:  binaryIDGlStencilThenCoverStrokePathInstancedNV,
	Package: "gles",
	Name:    "GlStencilThenCoverStrokePathInstancedNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "PathNameType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
		{Declared: "PathBase", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Reference", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlStencilThenCoverStrokePathNV struct{}

func (*GlStencilThenCoverStrokePathNV) Class() binary.Class {
	return (*binaryClassGlStencilThenCoverStrokePathNV)(nil)
}
func doEncodeGlStencilThenCoverStrokePathNV(e binary.Encoder, o *GlStencilThenCoverStrokePathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Path)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Reference)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Mask)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.CoverMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlStencilThenCoverStrokePathNV(d binary.Decoder, o *GlStencilThenCoverStrokePathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Path = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Reference = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Mask = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CoverMode = GLenum(obj)
	}
	return nil
}
func doSkipGlStencilThenCoverStrokePathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlStencilThenCoverStrokePathNV) ID() binary.ID {
	return binaryIDGlStencilThenCoverStrokePathNV
}
func (*binaryClassGlStencilThenCoverStrokePathNV) New() binary.Object {
	return &GlStencilThenCoverStrokePathNV{}
}
func (*binaryClassGlStencilThenCoverStrokePathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlStencilThenCoverStrokePathNV(e, obj.(*GlStencilThenCoverStrokePathNV))
}
func (*binaryClassGlStencilThenCoverStrokePathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlStencilThenCoverStrokePathNV{}
	return obj, doDecodeGlStencilThenCoverStrokePathNV(d, obj)
}
func (*binaryClassGlStencilThenCoverStrokePathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlStencilThenCoverStrokePathNV(d, obj.(*GlStencilThenCoverStrokePathNV))
}
func (*binaryClassGlStencilThenCoverStrokePathNV) Skip(d binary.Decoder) error {
	return doSkipGlStencilThenCoverStrokePathNV(d)
}
func (*binaryClassGlStencilThenCoverStrokePathNV) Schema() *schema.Class {
	return schemaGlStencilThenCoverStrokePathNV
}

var schemaGlStencilThenCoverStrokePathNV = &schema.Class{
	TypeID:  binaryIDGlStencilThenCoverStrokePathNV,
	Package: "gles",
	Name:    "GlStencilThenCoverStrokePathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Reference", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "CoverMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlSubpixelPrecisionBiasNV struct{}

func (*GlSubpixelPrecisionBiasNV) Class() binary.Class {
	return (*binaryClassGlSubpixelPrecisionBiasNV)(nil)
}
func doEncodeGlSubpixelPrecisionBiasNV(e binary.Encoder, o *GlSubpixelPrecisionBiasNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Xbits)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Ybits)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlSubpixelPrecisionBiasNV(d binary.Decoder, o *GlSubpixelPrecisionBiasNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Xbits = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Ybits = GLuint(obj)
	}
	return nil
}
func doSkipGlSubpixelPrecisionBiasNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlSubpixelPrecisionBiasNV) ID() binary.ID      { return binaryIDGlSubpixelPrecisionBiasNV }
func (*binaryClassGlSubpixelPrecisionBiasNV) New() binary.Object { return &GlSubpixelPrecisionBiasNV{} }
func (*binaryClassGlSubpixelPrecisionBiasNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlSubpixelPrecisionBiasNV(e, obj.(*GlSubpixelPrecisionBiasNV))
}
func (*binaryClassGlSubpixelPrecisionBiasNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlSubpixelPrecisionBiasNV{}
	return obj, doDecodeGlSubpixelPrecisionBiasNV(d, obj)
}
func (*binaryClassGlSubpixelPrecisionBiasNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlSubpixelPrecisionBiasNV(d, obj.(*GlSubpixelPrecisionBiasNV))
}
func (*binaryClassGlSubpixelPrecisionBiasNV) Skip(d binary.Decoder) error {
	return doSkipGlSubpixelPrecisionBiasNV(d)
}
func (*binaryClassGlSubpixelPrecisionBiasNV) Schema() *schema.Class {
	return schemaGlSubpixelPrecisionBiasNV
}

var schemaGlSubpixelPrecisionBiasNV = &schema.Class{
	TypeID:  binaryIDGlSubpixelPrecisionBiasNV,
	Package: "gles",
	Name:    "GlSubpixelPrecisionBiasNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Xbits", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Ybits", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlTestFenceNV struct{}

func (*GlTestFenceNV) Class() binary.Class {
	return (*binaryClassGlTestFenceNV)(nil)
}
func doEncodeGlTestFenceNV(e binary.Encoder, o *GlTestFenceNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Fence)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTestFenceNV(d binary.Decoder, o *GlTestFenceNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fence = GLuint(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlTestFenceNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTestFenceNV) ID() binary.ID      { return binaryIDGlTestFenceNV }
func (*binaryClassGlTestFenceNV) New() binary.Object { return &GlTestFenceNV{} }
func (*binaryClassGlTestFenceNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTestFenceNV(e, obj.(*GlTestFenceNV))
}
func (*binaryClassGlTestFenceNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTestFenceNV{}
	return obj, doDecodeGlTestFenceNV(d, obj)
}
func (*binaryClassGlTestFenceNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTestFenceNV(d, obj.(*GlTestFenceNV))
}
func (*binaryClassGlTestFenceNV) Skip(d binary.Decoder) error { return doSkipGlTestFenceNV(d) }
func (*binaryClassGlTestFenceNV) Schema() *schema.Class       { return schemaGlTestFenceNV }

var schemaGlTestFenceNV = &schema.Class{
	TypeID:  binaryIDGlTestFenceNV,
	Package: "gles",
	Name:    "GlTestFenceNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlTexBufferEXT struct{}

func (*GlTexBufferEXT) Class() binary.Class {
	return (*binaryClassGlTexBufferEXT)(nil)
}
func doEncodeGlTexBufferEXT(e binary.Encoder, o *GlTexBufferEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexBufferEXT(d binary.Decoder, o *GlTexBufferEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	return nil
}
func doSkipGlTexBufferEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexBufferEXT) ID() binary.ID      { return binaryIDGlTexBufferEXT }
func (*binaryClassGlTexBufferEXT) New() binary.Object { return &GlTexBufferEXT{} }
func (*binaryClassGlTexBufferEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexBufferEXT(e, obj.(*GlTexBufferEXT))
}
func (*binaryClassGlTexBufferEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexBufferEXT{}
	return obj, doDecodeGlTexBufferEXT(d, obj)
}
func (*binaryClassGlTexBufferEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexBufferEXT(d, obj.(*GlTexBufferEXT))
}
func (*binaryClassGlTexBufferEXT) Skip(d binary.Decoder) error { return doSkipGlTexBufferEXT(d) }
func (*binaryClassGlTexBufferEXT) Schema() *schema.Class       { return schemaGlTexBufferEXT }

var schemaGlTexBufferEXT = &schema.Class{
	TypeID:  binaryIDGlTexBufferEXT,
	Package: "gles",
	Name:    "GlTexBufferEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlTexBufferOES struct{}

func (*GlTexBufferOES) Class() binary.Class {
	return (*binaryClassGlTexBufferOES)(nil)
}
func doEncodeGlTexBufferOES(e binary.Encoder, o *GlTexBufferOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexBufferOES(d binary.Decoder, o *GlTexBufferOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	return nil
}
func doSkipGlTexBufferOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexBufferOES) ID() binary.ID      { return binaryIDGlTexBufferOES }
func (*binaryClassGlTexBufferOES) New() binary.Object { return &GlTexBufferOES{} }
func (*binaryClassGlTexBufferOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexBufferOES(e, obj.(*GlTexBufferOES))
}
func (*binaryClassGlTexBufferOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexBufferOES{}
	return obj, doDecodeGlTexBufferOES(d, obj)
}
func (*binaryClassGlTexBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexBufferOES(d, obj.(*GlTexBufferOES))
}
func (*binaryClassGlTexBufferOES) Skip(d binary.Decoder) error { return doSkipGlTexBufferOES(d) }
func (*binaryClassGlTexBufferOES) Schema() *schema.Class       { return schemaGlTexBufferOES }

var schemaGlTexBufferOES = &schema.Class{
	TypeID:  binaryIDGlTexBufferOES,
	Package: "gles",
	Name:    "GlTexBufferOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
	},
}

type binaryClassGlTexBufferRangeEXT struct{}

func (*GlTexBufferRangeEXT) Class() binary.Class {
	return (*binaryClassGlTexBufferRangeEXT)(nil)
}
func doEncodeGlTexBufferRangeEXT(e binary.Encoder, o *GlTexBufferRangeEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexBufferRangeEXT(d binary.Decoder, o *GlTexBufferRangeEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlTexBufferRangeEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexBufferRangeEXT) ID() binary.ID      { return binaryIDGlTexBufferRangeEXT }
func (*binaryClassGlTexBufferRangeEXT) New() binary.Object { return &GlTexBufferRangeEXT{} }
func (*binaryClassGlTexBufferRangeEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexBufferRangeEXT(e, obj.(*GlTexBufferRangeEXT))
}
func (*binaryClassGlTexBufferRangeEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexBufferRangeEXT{}
	return obj, doDecodeGlTexBufferRangeEXT(d, obj)
}
func (*binaryClassGlTexBufferRangeEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexBufferRangeEXT(d, obj.(*GlTexBufferRangeEXT))
}
func (*binaryClassGlTexBufferRangeEXT) Skip(d binary.Decoder) error {
	return doSkipGlTexBufferRangeEXT(d)
}
func (*binaryClassGlTexBufferRangeEXT) Schema() *schema.Class { return schemaGlTexBufferRangeEXT }

var schemaGlTexBufferRangeEXT = &schema.Class{
	TypeID:  binaryIDGlTexBufferRangeEXT,
	Package: "gles",
	Name:    "GlTexBufferRangeEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlTexBufferRangeOES struct{}

func (*GlTexBufferRangeOES) Class() binary.Class {
	return (*binaryClassGlTexBufferRangeOES)(nil)
}
func doEncodeGlTexBufferRangeOES(e binary.Encoder, o *GlTexBufferRangeOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Buffer)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Offset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexBufferRangeOES(d binary.Decoder, o *GlTexBufferRangeOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Buffer = BufferId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Offset = GLintptr(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLsizeiptr(obj)
	}
	return nil
}
func doSkipGlTexBufferRangeOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexBufferRangeOES) ID() binary.ID      { return binaryIDGlTexBufferRangeOES }
func (*binaryClassGlTexBufferRangeOES) New() binary.Object { return &GlTexBufferRangeOES{} }
func (*binaryClassGlTexBufferRangeOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexBufferRangeOES(e, obj.(*GlTexBufferRangeOES))
}
func (*binaryClassGlTexBufferRangeOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexBufferRangeOES{}
	return obj, doDecodeGlTexBufferRangeOES(d, obj)
}
func (*binaryClassGlTexBufferRangeOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexBufferRangeOES(d, obj.(*GlTexBufferRangeOES))
}
func (*binaryClassGlTexBufferRangeOES) Skip(d binary.Decoder) error {
	return doSkipGlTexBufferRangeOES(d)
}
func (*binaryClassGlTexBufferRangeOES) Schema() *schema.Class { return schemaGlTexBufferRangeOES }

var schemaGlTexBufferRangeOES = &schema.Class{
	TypeID:  binaryIDGlTexBufferRangeOES,
	Package: "gles",
	Name:    "GlTexBufferRangeOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}},
		{Declared: "Offset", Type: &schema.Primitive{Name: "GLintptr", Method: schema.Int32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLsizeiptr", Method: schema.Int32}},
	},
}

type binaryClassGlTexImage2D struct{}

func (*GlTexImage2D) Class() binary.Class {
	return (*binaryClassGlTexImage2D)(nil)
}
func doEncodeGlTexImage2D(e binary.Encoder, o *GlTexImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.InternalFormat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexImage2D(d binary.Decoder, o *GlTexImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.InternalFormat = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexImage2D) ID() binary.ID      { return binaryIDGlTexImage2D }
func (*binaryClassGlTexImage2D) New() binary.Object { return &GlTexImage2D{} }
func (*binaryClassGlTexImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexImage2D(e, obj.(*GlTexImage2D))
}
func (*binaryClassGlTexImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexImage2D{}
	return obj, doDecodeGlTexImage2D(d, obj)
}
func (*binaryClassGlTexImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexImage2D(d, obj.(*GlTexImage2D))
}
func (*binaryClassGlTexImage2D) Skip(d binary.Decoder) error { return doSkipGlTexImage2D(d) }
func (*binaryClassGlTexImage2D) Schema() *schema.Class       { return schemaGlTexImage2D }

var schemaGlTexImage2D = &schema.Class{
	TypeID:  binaryIDGlTexImage2D,
	Package: "gles",
	Name:    "GlTexImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "InternalFormat", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer", ID: (*TexturePointer)(nil).Class().ID()}},
	},
}

type binaryClassGlTexImage3D struct{}

func (*GlTexImage3D) Class() binary.Class {
	return (*binaryClassGlTexImage3D)(nil)
}
func doEncodeGlTexImage3D(e binary.Encoder, o *GlTexImage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexImage3D(d binary.Decoder, o *GlTexImage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Internalformat = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexImage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexImage3D) ID() binary.ID      { return binaryIDGlTexImage3D }
func (*binaryClassGlTexImage3D) New() binary.Object { return &GlTexImage3D{} }
func (*binaryClassGlTexImage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexImage3D(e, obj.(*GlTexImage3D))
}
func (*binaryClassGlTexImage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexImage3D{}
	return obj, doDecodeGlTexImage3D(d, obj)
}
func (*binaryClassGlTexImage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexImage3D(d, obj.(*GlTexImage3D))
}
func (*binaryClassGlTexImage3D) Skip(d binary.Decoder) error { return doSkipGlTexImage3D(d) }
func (*binaryClassGlTexImage3D) Schema() *schema.Class       { return schemaGlTexImage3D }

var schemaGlTexImage3D = &schema.Class{
	TypeID:  binaryIDGlTexImage3D,
	Package: "gles",
	Name:    "GlTexImage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pixels", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexImage3DOES struct{}

func (*GlTexImage3DOES) Class() binary.Class {
	return (*binaryClassGlTexImage3DOES)(nil)
}
func doEncodeGlTexImage3DOES(e binary.Encoder, o *GlTexImage3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Border)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexImage3DOES(d binary.Decoder, o *GlTexImage3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Border = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexImage3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexImage3DOES) ID() binary.ID      { return binaryIDGlTexImage3DOES }
func (*binaryClassGlTexImage3DOES) New() binary.Object { return &GlTexImage3DOES{} }
func (*binaryClassGlTexImage3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexImage3DOES(e, obj.(*GlTexImage3DOES))
}
func (*binaryClassGlTexImage3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexImage3DOES{}
	return obj, doDecodeGlTexImage3DOES(d, obj)
}
func (*binaryClassGlTexImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexImage3DOES(d, obj.(*GlTexImage3DOES))
}
func (*binaryClassGlTexImage3DOES) Skip(d binary.Decoder) error { return doSkipGlTexImage3DOES(d) }
func (*binaryClassGlTexImage3DOES) Schema() *schema.Class       { return schemaGlTexImage3DOES }

var schemaGlTexImage3DOES = &schema.Class{
	TypeID:  binaryIDGlTexImage3DOES,
	Package: "gles",
	Name:    "GlTexImage3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Border", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pixels", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexPageCommitmentARB struct{}

func (*GlTexPageCommitmentARB) Class() binary.Class {
	return (*binaryClassGlTexPageCommitmentARB)(nil)
}
func doEncodeGlTexPageCommitmentARB(e binary.Encoder, o *GlTexPageCommitmentARB) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Commit)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexPageCommitmentARB(d binary.Decoder, o *GlTexPageCommitmentARB) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Commit = GLboolean(obj)
	}
	return nil
}
func doSkipGlTexPageCommitmentARB(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexPageCommitmentARB) ID() binary.ID      { return binaryIDGlTexPageCommitmentARB }
func (*binaryClassGlTexPageCommitmentARB) New() binary.Object { return &GlTexPageCommitmentARB{} }
func (*binaryClassGlTexPageCommitmentARB) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexPageCommitmentARB(e, obj.(*GlTexPageCommitmentARB))
}
func (*binaryClassGlTexPageCommitmentARB) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexPageCommitmentARB{}
	return obj, doDecodeGlTexPageCommitmentARB(d, obj)
}
func (*binaryClassGlTexPageCommitmentARB) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexPageCommitmentARB(d, obj.(*GlTexPageCommitmentARB))
}
func (*binaryClassGlTexPageCommitmentARB) Skip(d binary.Decoder) error {
	return doSkipGlTexPageCommitmentARB(d)
}
func (*binaryClassGlTexPageCommitmentARB) Schema() *schema.Class { return schemaGlTexPageCommitmentARB }

var schemaGlTexPageCommitmentARB = &schema.Class{
	TypeID:  binaryIDGlTexPageCommitmentARB,
	Package: "gles",
	Name:    "GlTexPageCommitmentARB",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Commit", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlTexParameterIivEXT struct{}

func (*GlTexParameterIivEXT) Class() binary.Class {
	return (*binaryClassGlTexParameterIivEXT)(nil)
}
func doEncodeGlTexParameterIivEXT(e binary.Encoder, o *GlTexParameterIivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterIivEXT(d binary.Decoder, o *GlTexParameterIivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameterIivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterIivEXT) ID() binary.ID      { return binaryIDGlTexParameterIivEXT }
func (*binaryClassGlTexParameterIivEXT) New() binary.Object { return &GlTexParameterIivEXT{} }
func (*binaryClassGlTexParameterIivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterIivEXT(e, obj.(*GlTexParameterIivEXT))
}
func (*binaryClassGlTexParameterIivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterIivEXT{}
	return obj, doDecodeGlTexParameterIivEXT(d, obj)
}
func (*binaryClassGlTexParameterIivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterIivEXT(d, obj.(*GlTexParameterIivEXT))
}
func (*binaryClassGlTexParameterIivEXT) Skip(d binary.Decoder) error {
	return doSkipGlTexParameterIivEXT(d)
}
func (*binaryClassGlTexParameterIivEXT) Schema() *schema.Class { return schemaGlTexParameterIivEXT }

var schemaGlTexParameterIivEXT = &schema.Class{
	TypeID:  binaryIDGlTexParameterIivEXT,
	Package: "gles",
	Name:    "GlTexParameterIivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexParameterIivOES struct{}

func (*GlTexParameterIivOES) Class() binary.Class {
	return (*binaryClassGlTexParameterIivOES)(nil)
}
func doEncodeGlTexParameterIivOES(e binary.Encoder, o *GlTexParameterIivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterIivOES(d binary.Decoder, o *GlTexParameterIivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameterIivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterIivOES) ID() binary.ID      { return binaryIDGlTexParameterIivOES }
func (*binaryClassGlTexParameterIivOES) New() binary.Object { return &GlTexParameterIivOES{} }
func (*binaryClassGlTexParameterIivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterIivOES(e, obj.(*GlTexParameterIivOES))
}
func (*binaryClassGlTexParameterIivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterIivOES{}
	return obj, doDecodeGlTexParameterIivOES(d, obj)
}
func (*binaryClassGlTexParameterIivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterIivOES(d, obj.(*GlTexParameterIivOES))
}
func (*binaryClassGlTexParameterIivOES) Skip(d binary.Decoder) error {
	return doSkipGlTexParameterIivOES(d)
}
func (*binaryClassGlTexParameterIivOES) Schema() *schema.Class { return schemaGlTexParameterIivOES }

var schemaGlTexParameterIivOES = &schema.Class{
	TypeID:  binaryIDGlTexParameterIivOES,
	Package: "gles",
	Name:    "GlTexParameterIivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexParameterIuivEXT struct{}

func (*GlTexParameterIuivEXT) Class() binary.Class {
	return (*binaryClassGlTexParameterIuivEXT)(nil)
}
func doEncodeGlTexParameterIuivEXT(e binary.Encoder, o *GlTexParameterIuivEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterIuivEXT(d binary.Decoder, o *GlTexParameterIuivEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameterIuivEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterIuivEXT) ID() binary.ID      { return binaryIDGlTexParameterIuivEXT }
func (*binaryClassGlTexParameterIuivEXT) New() binary.Object { return &GlTexParameterIuivEXT{} }
func (*binaryClassGlTexParameterIuivEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterIuivEXT(e, obj.(*GlTexParameterIuivEXT))
}
func (*binaryClassGlTexParameterIuivEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterIuivEXT{}
	return obj, doDecodeGlTexParameterIuivEXT(d, obj)
}
func (*binaryClassGlTexParameterIuivEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterIuivEXT(d, obj.(*GlTexParameterIuivEXT))
}
func (*binaryClassGlTexParameterIuivEXT) Skip(d binary.Decoder) error {
	return doSkipGlTexParameterIuivEXT(d)
}
func (*binaryClassGlTexParameterIuivEXT) Schema() *schema.Class { return schemaGlTexParameterIuivEXT }

var schemaGlTexParameterIuivEXT = &schema.Class{
	TypeID:  binaryIDGlTexParameterIuivEXT,
	Package: "gles",
	Name:    "GlTexParameterIuivEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexParameterIuivOES struct{}

func (*GlTexParameterIuivOES) Class() binary.Class {
	return (*binaryClassGlTexParameterIuivOES)(nil)
}
func doEncodeGlTexParameterIuivOES(e binary.Encoder, o *GlTexParameterIuivOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterIuivOES(d binary.Decoder, o *GlTexParameterIuivOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameterIuivOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterIuivOES) ID() binary.ID      { return binaryIDGlTexParameterIuivOES }
func (*binaryClassGlTexParameterIuivOES) New() binary.Object { return &GlTexParameterIuivOES{} }
func (*binaryClassGlTexParameterIuivOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterIuivOES(e, obj.(*GlTexParameterIuivOES))
}
func (*binaryClassGlTexParameterIuivOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterIuivOES{}
	return obj, doDecodeGlTexParameterIuivOES(d, obj)
}
func (*binaryClassGlTexParameterIuivOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterIuivOES(d, obj.(*GlTexParameterIuivOES))
}
func (*binaryClassGlTexParameterIuivOES) Skip(d binary.Decoder) error {
	return doSkipGlTexParameterIuivOES(d)
}
func (*binaryClassGlTexParameterIuivOES) Schema() *schema.Class { return schemaGlTexParameterIuivOES }

var schemaGlTexParameterIuivOES = &schema.Class{
	TypeID:  binaryIDGlTexParameterIuivOES,
	Package: "gles",
	Name:    "GlTexParameterIuivOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexParameterf struct{}

func (*GlTexParameterf) Class() binary.Class {
	return (*binaryClassGlTexParameterf)(nil)
}
func doEncodeGlTexParameterf(e binary.Encoder, o *GlTexParameterf) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterf(d binary.Decoder, o *GlTexParameterf) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value = GLfloat(obj)
	}
	return nil
}
func doSkipGlTexParameterf(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterf) ID() binary.ID      { return binaryIDGlTexParameterf }
func (*binaryClassGlTexParameterf) New() binary.Object { return &GlTexParameterf{} }
func (*binaryClassGlTexParameterf) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterf(e, obj.(*GlTexParameterf))
}
func (*binaryClassGlTexParameterf) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterf{}
	return obj, doDecodeGlTexParameterf(d, obj)
}
func (*binaryClassGlTexParameterf) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterf(d, obj.(*GlTexParameterf))
}
func (*binaryClassGlTexParameterf) Skip(d binary.Decoder) error { return doSkipGlTexParameterf(d) }
func (*binaryClassGlTexParameterf) Schema() *schema.Class       { return schemaGlTexParameterf }

var schemaGlTexParameterf = &schema.Class{
	TypeID:  binaryIDGlTexParameterf,
	Package: "gles",
	Name:    "GlTexParameterf",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlTexParameterfv struct{}

func (*GlTexParameterfv) Class() binary.Class {
	return (*binaryClassGlTexParameterfv)(nil)
}
func doEncodeGlTexParameterfv(e binary.Encoder, o *GlTexParameterfv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameterfv(d binary.Decoder, o *GlTexParameterfv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameterfv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameterfv) ID() binary.ID      { return binaryIDGlTexParameterfv }
func (*binaryClassGlTexParameterfv) New() binary.Object { return &GlTexParameterfv{} }
func (*binaryClassGlTexParameterfv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameterfv(e, obj.(*GlTexParameterfv))
}
func (*binaryClassGlTexParameterfv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameterfv{}
	return obj, doDecodeGlTexParameterfv(d, obj)
}
func (*binaryClassGlTexParameterfv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameterfv(d, obj.(*GlTexParameterfv))
}
func (*binaryClassGlTexParameterfv) Skip(d binary.Decoder) error { return doSkipGlTexParameterfv(d) }
func (*binaryClassGlTexParameterfv) Schema() *schema.Class       { return schemaGlTexParameterfv }

var schemaGlTexParameterfv = &schema.Class{
	TypeID:  binaryIDGlTexParameterfv,
	Package: "gles",
	Name:    "GlTexParameterfv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexParameteri struct{}

func (*GlTexParameteri) Class() binary.Class {
	return (*binaryClassGlTexParameteri)(nil)
}
func doEncodeGlTexParameteri(e binary.Encoder, o *GlTexParameteri) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Parameter)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameteri(d binary.Decoder, o *GlTexParameteri) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameter = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlTexParameteri(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameteri) ID() binary.ID      { return binaryIDGlTexParameteri }
func (*binaryClassGlTexParameteri) New() binary.Object { return &GlTexParameteri{} }
func (*binaryClassGlTexParameteri) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameteri(e, obj.(*GlTexParameteri))
}
func (*binaryClassGlTexParameteri) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameteri{}
	return obj, doDecodeGlTexParameteri(d, obj)
}
func (*binaryClassGlTexParameteri) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameteri(d, obj.(*GlTexParameteri))
}
func (*binaryClassGlTexParameteri) Skip(d binary.Decoder) error { return doSkipGlTexParameteri(d) }
func (*binaryClassGlTexParameteri) Schema() *schema.Class       { return schemaGlTexParameteri }

var schemaGlTexParameteri = &schema.Class{
	TypeID:  binaryIDGlTexParameteri,
	Package: "gles",
	Name:    "GlTexParameteri",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Parameter", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlTexParameteriv struct{}

func (*GlTexParameteriv) Class() binary.Class {
	return (*binaryClassGlTexParameteriv)(nil)
}
func doEncodeGlTexParameteriv(e binary.Encoder, o *GlTexParameteriv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pname)); err != nil {
		return err
	}
	if err := e.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexParameteriv(d binary.Decoder, o *GlTexParameteriv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pname = GLenum(obj)
	}
	if err := d.Value(&o.Params); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexParameteriv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexParameteriv) ID() binary.ID      { return binaryIDGlTexParameteriv }
func (*binaryClassGlTexParameteriv) New() binary.Object { return &GlTexParameteriv{} }
func (*binaryClassGlTexParameteriv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexParameteriv(e, obj.(*GlTexParameteriv))
}
func (*binaryClassGlTexParameteriv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexParameteriv{}
	return obj, doDecodeGlTexParameteriv(d, obj)
}
func (*binaryClassGlTexParameteriv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexParameteriv(d, obj.(*GlTexParameteriv))
}
func (*binaryClassGlTexParameteriv) Skip(d binary.Decoder) error { return doSkipGlTexParameteriv(d) }
func (*binaryClassGlTexParameteriv) Schema() *schema.Class       { return schemaGlTexParameteriv }

var schemaGlTexParameteriv = &schema.Class{
	TypeID:  binaryIDGlTexParameteriv,
	Package: "gles",
	Name:    "GlTexParameteriv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pname", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Params", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexStorage1DEXT struct{}

func (*GlTexStorage1DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage1DEXT)(nil)
}
func doEncodeGlTexStorage1DEXT(e binary.Encoder, o *GlTexStorage1DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage1DEXT(d binary.Decoder, o *GlTexStorage1DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	return nil
}
func doSkipGlTexStorage1DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage1DEXT) ID() binary.ID      { return binaryIDGlTexStorage1DEXT }
func (*binaryClassGlTexStorage1DEXT) New() binary.Object { return &GlTexStorage1DEXT{} }
func (*binaryClassGlTexStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage1DEXT(e, obj.(*GlTexStorage1DEXT))
}
func (*binaryClassGlTexStorage1DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage1DEXT{}
	return obj, doDecodeGlTexStorage1DEXT(d, obj)
}
func (*binaryClassGlTexStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage1DEXT(d, obj.(*GlTexStorage1DEXT))
}
func (*binaryClassGlTexStorage1DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage1DEXT(d) }
func (*binaryClassGlTexStorage1DEXT) Schema() *schema.Class       { return schemaGlTexStorage1DEXT }

var schemaGlTexStorage1DEXT = &schema.Class{
	TypeID:  binaryIDGlTexStorage1DEXT,
	Package: "gles",
	Name:    "GlTexStorage1DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTexStorage2D struct{}

func (*GlTexStorage2D) Class() binary.Class {
	return (*binaryClassGlTexStorage2D)(nil)
}
func doEncodeGlTexStorage2D(e binary.Encoder, o *GlTexStorage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage2D(d binary.Decoder, o *GlTexStorage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlTexStorage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage2D) ID() binary.ID      { return binaryIDGlTexStorage2D }
func (*binaryClassGlTexStorage2D) New() binary.Object { return &GlTexStorage2D{} }
func (*binaryClassGlTexStorage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage2D(e, obj.(*GlTexStorage2D))
}
func (*binaryClassGlTexStorage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage2D{}
	return obj, doDecodeGlTexStorage2D(d, obj)
}
func (*binaryClassGlTexStorage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage2D(d, obj.(*GlTexStorage2D))
}
func (*binaryClassGlTexStorage2D) Skip(d binary.Decoder) error { return doSkipGlTexStorage2D(d) }
func (*binaryClassGlTexStorage2D) Schema() *schema.Class       { return schemaGlTexStorage2D }

var schemaGlTexStorage2D = &schema.Class{
	TypeID:  binaryIDGlTexStorage2D,
	Package: "gles",
	Name:    "GlTexStorage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTexStorage2DEXT struct{}

func (*GlTexStorage2DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage2DEXT)(nil)
}
func doEncodeGlTexStorage2DEXT(e binary.Encoder, o *GlTexStorage2DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage2DEXT(d binary.Decoder, o *GlTexStorage2DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlTexStorage2DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage2DEXT) ID() binary.ID      { return binaryIDGlTexStorage2DEXT }
func (*binaryClassGlTexStorage2DEXT) New() binary.Object { return &GlTexStorage2DEXT{} }
func (*binaryClassGlTexStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage2DEXT(e, obj.(*GlTexStorage2DEXT))
}
func (*binaryClassGlTexStorage2DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage2DEXT{}
	return obj, doDecodeGlTexStorage2DEXT(d, obj)
}
func (*binaryClassGlTexStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage2DEXT(d, obj.(*GlTexStorage2DEXT))
}
func (*binaryClassGlTexStorage2DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage2DEXT(d) }
func (*binaryClassGlTexStorage2DEXT) Schema() *schema.Class       { return schemaGlTexStorage2DEXT }

var schemaGlTexStorage2DEXT = &schema.Class{
	TypeID:  binaryIDGlTexStorage2DEXT,
	Package: "gles",
	Name:    "GlTexStorage2DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTexStorage2DMultisample struct{}

func (*GlTexStorage2DMultisample) Class() binary.Class {
	return (*binaryClassGlTexStorage2DMultisample)(nil)
}
func doEncodeGlTexStorage2DMultisample(e binary.Encoder, o *GlTexStorage2DMultisample) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Fixedsamplelocations)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage2DMultisample(d binary.Decoder, o *GlTexStorage2DMultisample) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Fixedsamplelocations = GLboolean(obj)
	}
	return nil
}
func doSkipGlTexStorage2DMultisample(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage2DMultisample) ID() binary.ID      { return binaryIDGlTexStorage2DMultisample }
func (*binaryClassGlTexStorage2DMultisample) New() binary.Object { return &GlTexStorage2DMultisample{} }
func (*binaryClassGlTexStorage2DMultisample) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage2DMultisample(e, obj.(*GlTexStorage2DMultisample))
}
func (*binaryClassGlTexStorage2DMultisample) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage2DMultisample{}
	return obj, doDecodeGlTexStorage2DMultisample(d, obj)
}
func (*binaryClassGlTexStorage2DMultisample) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage2DMultisample(d, obj.(*GlTexStorage2DMultisample))
}
func (*binaryClassGlTexStorage2DMultisample) Skip(d binary.Decoder) error {
	return doSkipGlTexStorage2DMultisample(d)
}
func (*binaryClassGlTexStorage2DMultisample) Schema() *schema.Class {
	return schemaGlTexStorage2DMultisample
}

var schemaGlTexStorage2DMultisample = &schema.Class{
	TypeID:  binaryIDGlTexStorage2DMultisample,
	Package: "gles",
	Name:    "GlTexStorage2DMultisample",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Fixedsamplelocations", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlTexStorage3D struct{}

func (*GlTexStorage3D) Class() binary.Class {
	return (*binaryClassGlTexStorage3D)(nil)
}
func doEncodeGlTexStorage3D(e binary.Encoder, o *GlTexStorage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage3D(d binary.Decoder, o *GlTexStorage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	return nil
}
func doSkipGlTexStorage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage3D) ID() binary.ID      { return binaryIDGlTexStorage3D }
func (*binaryClassGlTexStorage3D) New() binary.Object { return &GlTexStorage3D{} }
func (*binaryClassGlTexStorage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage3D(e, obj.(*GlTexStorage3D))
}
func (*binaryClassGlTexStorage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage3D{}
	return obj, doDecodeGlTexStorage3D(d, obj)
}
func (*binaryClassGlTexStorage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage3D(d, obj.(*GlTexStorage3D))
}
func (*binaryClassGlTexStorage3D) Skip(d binary.Decoder) error { return doSkipGlTexStorage3D(d) }
func (*binaryClassGlTexStorage3D) Schema() *schema.Class       { return schemaGlTexStorage3D }

var schemaGlTexStorage3D = &schema.Class{
	TypeID:  binaryIDGlTexStorage3D,
	Package: "gles",
	Name:    "GlTexStorage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTexStorage3DEXT struct{}

func (*GlTexStorage3DEXT) Class() binary.Class {
	return (*binaryClassGlTexStorage3DEXT)(nil)
}
func doEncodeGlTexStorage3DEXT(e binary.Encoder, o *GlTexStorage3DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage3DEXT(d binary.Decoder, o *GlTexStorage3DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	return nil
}
func doSkipGlTexStorage3DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage3DEXT) ID() binary.ID      { return binaryIDGlTexStorage3DEXT }
func (*binaryClassGlTexStorage3DEXT) New() binary.Object { return &GlTexStorage3DEXT{} }
func (*binaryClassGlTexStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage3DEXT(e, obj.(*GlTexStorage3DEXT))
}
func (*binaryClassGlTexStorage3DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage3DEXT{}
	return obj, doDecodeGlTexStorage3DEXT(d, obj)
}
func (*binaryClassGlTexStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage3DEXT(d, obj.(*GlTexStorage3DEXT))
}
func (*binaryClassGlTexStorage3DEXT) Skip(d binary.Decoder) error { return doSkipGlTexStorage3DEXT(d) }
func (*binaryClassGlTexStorage3DEXT) Schema() *schema.Class       { return schemaGlTexStorage3DEXT }

var schemaGlTexStorage3DEXT = &schema.Class{
	TypeID:  binaryIDGlTexStorage3DEXT,
	Package: "gles",
	Name:    "GlTexStorage3DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTexStorage3DMultisampleOES struct{}

func (*GlTexStorage3DMultisampleOES) Class() binary.Class {
	return (*binaryClassGlTexStorage3DMultisampleOES)(nil)
}
func doEncodeGlTexStorage3DMultisampleOES(e binary.Encoder, o *GlTexStorage3DMultisampleOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Samples)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Fixedsamplelocations)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexStorage3DMultisampleOES(d binary.Decoder, o *GlTexStorage3DMultisampleOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Samples = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Fixedsamplelocations = GLboolean(obj)
	}
	return nil
}
func doSkipGlTexStorage3DMultisampleOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexStorage3DMultisampleOES) ID() binary.ID {
	return binaryIDGlTexStorage3DMultisampleOES
}
func (*binaryClassGlTexStorage3DMultisampleOES) New() binary.Object {
	return &GlTexStorage3DMultisampleOES{}
}
func (*binaryClassGlTexStorage3DMultisampleOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexStorage3DMultisampleOES(e, obj.(*GlTexStorage3DMultisampleOES))
}
func (*binaryClassGlTexStorage3DMultisampleOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexStorage3DMultisampleOES{}
	return obj, doDecodeGlTexStorage3DMultisampleOES(d, obj)
}
func (*binaryClassGlTexStorage3DMultisampleOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexStorage3DMultisampleOES(d, obj.(*GlTexStorage3DMultisampleOES))
}
func (*binaryClassGlTexStorage3DMultisampleOES) Skip(d binary.Decoder) error {
	return doSkipGlTexStorage3DMultisampleOES(d)
}
func (*binaryClassGlTexStorage3DMultisampleOES) Schema() *schema.Class {
	return schemaGlTexStorage3DMultisampleOES
}

var schemaGlTexStorage3DMultisampleOES = &schema.Class{
	TypeID:  binaryIDGlTexStorage3DMultisampleOES,
	Package: "gles",
	Name:    "GlTexStorage3DMultisampleOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Samples", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Fixedsamplelocations", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlTexSubImage2D struct{}

func (*GlTexSubImage2D) Class() binary.Class {
	return (*binaryClassGlTexSubImage2D)(nil)
}
func doEncodeGlTexSubImage2D(e binary.Encoder, o *GlTexSubImage2D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexSubImage2D(d binary.Decoder, o *GlTexSubImage2D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexSubImage2D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*TexturePointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexSubImage2D) ID() binary.ID      { return binaryIDGlTexSubImage2D }
func (*binaryClassGlTexSubImage2D) New() binary.Object { return &GlTexSubImage2D{} }
func (*binaryClassGlTexSubImage2D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexSubImage2D(e, obj.(*GlTexSubImage2D))
}
func (*binaryClassGlTexSubImage2D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexSubImage2D{}
	return obj, doDecodeGlTexSubImage2D(d, obj)
}
func (*binaryClassGlTexSubImage2D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexSubImage2D(d, obj.(*GlTexSubImage2D))
}
func (*binaryClassGlTexSubImage2D) Skip(d binary.Decoder) error { return doSkipGlTexSubImage2D(d) }
func (*binaryClassGlTexSubImage2D) Schema() *schema.Class       { return schemaGlTexSubImage2D }

var schemaGlTexSubImage2D = &schema.Class{
	TypeID:  binaryIDGlTexSubImage2D,
	Package: "gles",
	Name:    "GlTexSubImage2D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Data", Type: &schema.Struct{Name: "TexturePointer", ID: (*TexturePointer)(nil).Class().ID()}},
	},
}

type binaryClassGlTexSubImage3D struct{}

func (*GlTexSubImage3D) Class() binary.Class {
	return (*binaryClassGlTexSubImage3D)(nil)
}
func doEncodeGlTexSubImage3D(e binary.Encoder, o *GlTexSubImage3D) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexSubImage3D(d binary.Decoder, o *GlTexSubImage3D) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexSubImage3D(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexSubImage3D) ID() binary.ID      { return binaryIDGlTexSubImage3D }
func (*binaryClassGlTexSubImage3D) New() binary.Object { return &GlTexSubImage3D{} }
func (*binaryClassGlTexSubImage3D) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexSubImage3D(e, obj.(*GlTexSubImage3D))
}
func (*binaryClassGlTexSubImage3D) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexSubImage3D{}
	return obj, doDecodeGlTexSubImage3D(d, obj)
}
func (*binaryClassGlTexSubImage3D) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexSubImage3D(d, obj.(*GlTexSubImage3D))
}
func (*binaryClassGlTexSubImage3D) Skip(d binary.Decoder) error { return doSkipGlTexSubImage3D(d) }
func (*binaryClassGlTexSubImage3D) Schema() *schema.Class       { return schemaGlTexSubImage3D }

var schemaGlTexSubImage3D = &schema.Class{
	TypeID:  binaryIDGlTexSubImage3D,
	Package: "gles",
	Name:    "GlTexSubImage3D",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pixels", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTexSubImage3DOES struct{}

func (*GlTexSubImage3DOES) Class() binary.Class {
	return (*binaryClassGlTexSubImage3DOES)(nil)
}
func doEncodeGlTexSubImage3DOES(e binary.Encoder, o *GlTexSubImage3DOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Level)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Xoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Yoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Zoffset)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTexSubImage3DOES(d binary.Decoder, o *GlTexSubImage3DOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Level = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Xoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Yoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Zoffset = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if err := d.Value(&o.Pixels); err != nil {
		return err
	}
	return nil
}
func doSkipGlTexSubImage3DOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTexSubImage3DOES) ID() binary.ID      { return binaryIDGlTexSubImage3DOES }
func (*binaryClassGlTexSubImage3DOES) New() binary.Object { return &GlTexSubImage3DOES{} }
func (*binaryClassGlTexSubImage3DOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTexSubImage3DOES(e, obj.(*GlTexSubImage3DOES))
}
func (*binaryClassGlTexSubImage3DOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTexSubImage3DOES{}
	return obj, doDecodeGlTexSubImage3DOES(d, obj)
}
func (*binaryClassGlTexSubImage3DOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTexSubImage3DOES(d, obj.(*GlTexSubImage3DOES))
}
func (*binaryClassGlTexSubImage3DOES) Skip(d binary.Decoder) error { return doSkipGlTexSubImage3DOES(d) }
func (*binaryClassGlTexSubImage3DOES) Schema() *schema.Class       { return schemaGlTexSubImage3DOES }

var schemaGlTexSubImage3DOES = &schema.Class{
	TypeID:  binaryIDGlTexSubImage3DOES,
	Package: "gles",
	Name:    "GlTexSubImage3DOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Level", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Xoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Yoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Zoffset", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Pixels", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlTextureStorage1DEXT struct{}

func (*GlTextureStorage1DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage1DEXT)(nil)
}
func doEncodeGlTextureStorage1DEXT(e binary.Encoder, o *GlTextureStorage1DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTextureStorage1DEXT(d binary.Decoder, o *GlTextureStorage1DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	return nil
}
func doSkipGlTextureStorage1DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTextureStorage1DEXT) ID() binary.ID      { return binaryIDGlTextureStorage1DEXT }
func (*binaryClassGlTextureStorage1DEXT) New() binary.Object { return &GlTextureStorage1DEXT{} }
func (*binaryClassGlTextureStorage1DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTextureStorage1DEXT(e, obj.(*GlTextureStorage1DEXT))
}
func (*binaryClassGlTextureStorage1DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTextureStorage1DEXT{}
	return obj, doDecodeGlTextureStorage1DEXT(d, obj)
}
func (*binaryClassGlTextureStorage1DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTextureStorage1DEXT(d, obj.(*GlTextureStorage1DEXT))
}
func (*binaryClassGlTextureStorage1DEXT) Skip(d binary.Decoder) error {
	return doSkipGlTextureStorage1DEXT(d)
}
func (*binaryClassGlTextureStorage1DEXT) Schema() *schema.Class { return schemaGlTextureStorage1DEXT }

var schemaGlTextureStorage1DEXT = &schema.Class{
	TypeID:  binaryIDGlTextureStorage1DEXT,
	Package: "gles",
	Name:    "GlTextureStorage1DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTextureStorage2DEXT struct{}

func (*GlTextureStorage2DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage2DEXT)(nil)
}
func doEncodeGlTextureStorage2DEXT(e binary.Encoder, o *GlTextureStorage2DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTextureStorage2DEXT(d binary.Decoder, o *GlTextureStorage2DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlTextureStorage2DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTextureStorage2DEXT) ID() binary.ID      { return binaryIDGlTextureStorage2DEXT }
func (*binaryClassGlTextureStorage2DEXT) New() binary.Object { return &GlTextureStorage2DEXT{} }
func (*binaryClassGlTextureStorage2DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTextureStorage2DEXT(e, obj.(*GlTextureStorage2DEXT))
}
func (*binaryClassGlTextureStorage2DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTextureStorage2DEXT{}
	return obj, doDecodeGlTextureStorage2DEXT(d, obj)
}
func (*binaryClassGlTextureStorage2DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTextureStorage2DEXT(d, obj.(*GlTextureStorage2DEXT))
}
func (*binaryClassGlTextureStorage2DEXT) Skip(d binary.Decoder) error {
	return doSkipGlTextureStorage2DEXT(d)
}
func (*binaryClassGlTextureStorage2DEXT) Schema() *schema.Class { return schemaGlTextureStorage2DEXT }

var schemaGlTextureStorage2DEXT = &schema.Class{
	TypeID:  binaryIDGlTextureStorage2DEXT,
	Package: "gles",
	Name:    "GlTextureStorage2DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTextureStorage3DEXT struct{}

func (*GlTextureStorage3DEXT) Class() binary.Class {
	return (*binaryClassGlTextureStorage3DEXT)(nil)
}
func doEncodeGlTextureStorage3DEXT(e binary.Encoder, o *GlTextureStorage3DEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Levels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Format)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Depth)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTextureStorage3DEXT(d binary.Decoder, o *GlTextureStorage3DEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Levels = GLsizei(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Format = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Depth = GLsizei(obj)
	}
	return nil
}
func doSkipGlTextureStorage3DEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTextureStorage3DEXT) ID() binary.ID      { return binaryIDGlTextureStorage3DEXT }
func (*binaryClassGlTextureStorage3DEXT) New() binary.Object { return &GlTextureStorage3DEXT{} }
func (*binaryClassGlTextureStorage3DEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTextureStorage3DEXT(e, obj.(*GlTextureStorage3DEXT))
}
func (*binaryClassGlTextureStorage3DEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTextureStorage3DEXT{}
	return obj, doDecodeGlTextureStorage3DEXT(d, obj)
}
func (*binaryClassGlTextureStorage3DEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTextureStorage3DEXT(d, obj.(*GlTextureStorage3DEXT))
}
func (*binaryClassGlTextureStorage3DEXT) Skip(d binary.Decoder) error {
	return doSkipGlTextureStorage3DEXT(d)
}
func (*binaryClassGlTextureStorage3DEXT) Schema() *schema.Class { return schemaGlTextureStorage3DEXT }

var schemaGlTextureStorage3DEXT = &schema.Class{
	TypeID:  binaryIDGlTextureStorage3DEXT,
	Package: "gles",
	Name:    "GlTextureStorage3DEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Levels", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Format", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Depth", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlTextureViewEXT struct{}

func (*GlTextureViewEXT) Class() binary.Class {
	return (*binaryClassGlTextureViewEXT)(nil)
}
func doEncodeGlTextureViewEXT(e binary.Encoder, o *GlTextureViewEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Origtexture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Minlevel)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Numlevels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Minlayer)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Numlayers)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTextureViewEXT(d binary.Decoder, o *GlTextureViewEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Origtexture = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Minlevel = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Numlevels = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Minlayer = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Numlayers = GLuint(obj)
	}
	return nil
}
func doSkipGlTextureViewEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTextureViewEXT) ID() binary.ID      { return binaryIDGlTextureViewEXT }
func (*binaryClassGlTextureViewEXT) New() binary.Object { return &GlTextureViewEXT{} }
func (*binaryClassGlTextureViewEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTextureViewEXT(e, obj.(*GlTextureViewEXT))
}
func (*binaryClassGlTextureViewEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTextureViewEXT{}
	return obj, doDecodeGlTextureViewEXT(d, obj)
}
func (*binaryClassGlTextureViewEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTextureViewEXT(d, obj.(*GlTextureViewEXT))
}
func (*binaryClassGlTextureViewEXT) Skip(d binary.Decoder) error { return doSkipGlTextureViewEXT(d) }
func (*binaryClassGlTextureViewEXT) Schema() *schema.Class       { return schemaGlTextureViewEXT }

var schemaGlTextureViewEXT = &schema.Class{
	TypeID:  binaryIDGlTextureViewEXT,
	Package: "gles",
	Name:    "GlTextureViewEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Origtexture", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Minlevel", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Numlevels", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Minlayer", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Numlayers", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlTextureViewOES struct{}

func (*GlTextureViewOES) Class() binary.Class {
	return (*binaryClassGlTextureViewOES)(nil)
}
func doEncodeGlTextureViewOES(e binary.Encoder, o *GlTextureViewOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Texture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Origtexture)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Internalformat)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Minlevel)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Numlevels)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Minlayer)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Numlayers)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTextureViewOES(d binary.Decoder, o *GlTextureViewOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Texture = TextureId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Origtexture = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Internalformat = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Minlevel = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Numlevels = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Minlayer = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Numlayers = GLuint(obj)
	}
	return nil
}
func doSkipGlTextureViewOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTextureViewOES) ID() binary.ID      { return binaryIDGlTextureViewOES }
func (*binaryClassGlTextureViewOES) New() binary.Object { return &GlTextureViewOES{} }
func (*binaryClassGlTextureViewOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTextureViewOES(e, obj.(*GlTextureViewOES))
}
func (*binaryClassGlTextureViewOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTextureViewOES{}
	return obj, doDecodeGlTextureViewOES(d, obj)
}
func (*binaryClassGlTextureViewOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTextureViewOES(d, obj.(*GlTextureViewOES))
}
func (*binaryClassGlTextureViewOES) Skip(d binary.Decoder) error { return doSkipGlTextureViewOES(d) }
func (*binaryClassGlTextureViewOES) Schema() *schema.Class       { return schemaGlTextureViewOES }

var schemaGlTextureViewOES = &schema.Class{
	TypeID:  binaryIDGlTextureViewOES,
	Package: "gles",
	Name:    "GlTextureViewOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Origtexture", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Internalformat", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Minlevel", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Numlevels", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Minlayer", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Numlayers", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlTransformFeedbackVaryings struct{}

func (*GlTransformFeedbackVaryings) Class() binary.Class {
	return (*binaryClassGlTransformFeedbackVaryings)(nil)
}
func doEncodeGlTransformFeedbackVaryings(e binary.Encoder, o *GlTransformFeedbackVaryings) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Varyings); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.BufferMode)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTransformFeedbackVaryings(d binary.Decoder, o *GlTransformFeedbackVaryings) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Varyings); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.BufferMode = GLenum(obj)
	}
	return nil
}
func doSkipGlTransformFeedbackVaryings(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLcharᶜᵖᶜᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTransformFeedbackVaryings) ID() binary.ID {
	return binaryIDGlTransformFeedbackVaryings
}
func (*binaryClassGlTransformFeedbackVaryings) New() binary.Object {
	return &GlTransformFeedbackVaryings{}
}
func (*binaryClassGlTransformFeedbackVaryings) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTransformFeedbackVaryings(e, obj.(*GlTransformFeedbackVaryings))
}
func (*binaryClassGlTransformFeedbackVaryings) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTransformFeedbackVaryings{}
	return obj, doDecodeGlTransformFeedbackVaryings(d, obj)
}
func (*binaryClassGlTransformFeedbackVaryings) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTransformFeedbackVaryings(d, obj.(*GlTransformFeedbackVaryings))
}
func (*binaryClassGlTransformFeedbackVaryings) Skip(d binary.Decoder) error {
	return doSkipGlTransformFeedbackVaryings(d)
}
func (*binaryClassGlTransformFeedbackVaryings) Schema() *schema.Class {
	return schemaGlTransformFeedbackVaryings
}

var schemaGlTransformFeedbackVaryings = &schema.Class{
	TypeID:  binaryIDGlTransformFeedbackVaryings,
	Package: "gles",
	Name:    "GlTransformFeedbackVaryings",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Varyings", Type: &schema.Struct{Name: "GLcharᶜᵖᶜᵖ", ID: (*GLcharᶜᵖᶜᵖ)(nil).Class().ID()}},
		{Declared: "BufferMode", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
	},
}

type binaryClassGlTransformPathNV struct{}

func (*GlTransformPathNV) Class() binary.Class {
	return (*binaryClassGlTransformPathNV)(nil)
}
func doEncodeGlTransformPathNV(e binary.Encoder, o *GlTransformPathNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ResultPath)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SrcPath)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.TransformType)); err != nil {
		return err
	}
	if err := e.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doDecodeGlTransformPathNV(d binary.Decoder, o *GlTransformPathNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ResultPath = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SrcPath = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.TransformType = GLenum(obj)
	}
	if err := d.Value(&o.TransformValues); err != nil {
		return err
	}
	return nil
}
func doSkipGlTransformPathNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlTransformPathNV) ID() binary.ID      { return binaryIDGlTransformPathNV }
func (*binaryClassGlTransformPathNV) New() binary.Object { return &GlTransformPathNV{} }
func (*binaryClassGlTransformPathNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlTransformPathNV(e, obj.(*GlTransformPathNV))
}
func (*binaryClassGlTransformPathNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlTransformPathNV{}
	return obj, doDecodeGlTransformPathNV(d, obj)
}
func (*binaryClassGlTransformPathNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlTransformPathNV(d, obj.(*GlTransformPathNV))
}
func (*binaryClassGlTransformPathNV) Skip(d binary.Decoder) error { return doSkipGlTransformPathNV(d) }
func (*binaryClassGlTransformPathNV) Schema() *schema.Class       { return schemaGlTransformPathNV }

var schemaGlTransformPathNV = &schema.Class{
	TypeID:  binaryIDGlTransformPathNV,
	Package: "gles",
	Name:    "GlTransformPathNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ResultPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "SrcPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "TransformType", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "TransformValues", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform1f struct{}

func (*GlUniform1f) Class() binary.Class {
	return (*binaryClassGlUniform1f)(nil)
}
func doEncodeGlUniform1f(e binary.Encoder, o *GlUniform1f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1f(d binary.Decoder, o *GlUniform1f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value = GLfloat(obj)
	}
	return nil
}
func doSkipGlUniform1f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1f) ID() binary.ID      { return binaryIDGlUniform1f }
func (*binaryClassGlUniform1f) New() binary.Object { return &GlUniform1f{} }
func (*binaryClassGlUniform1f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1f(e, obj.(*GlUniform1f))
}
func (*binaryClassGlUniform1f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1f{}
	return obj, doDecodeGlUniform1f(d, obj)
}
func (*binaryClassGlUniform1f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1f(d, obj.(*GlUniform1f))
}
func (*binaryClassGlUniform1f) Skip(d binary.Decoder) error { return doSkipGlUniform1f(d) }
func (*binaryClassGlUniform1f) Schema() *schema.Class       { return schemaGlUniform1f }

var schemaGlUniform1f = &schema.Class{
	TypeID:  binaryIDGlUniform1f,
	Package: "gles",
	Name:    "GlUniform1f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlUniform1fv struct{}

func (*GlUniform1fv) Class() binary.Class {
	return (*binaryClassGlUniform1fv)(nil)
}
func doEncodeGlUniform1fv(e binary.Encoder, o *GlUniform1fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1fv(d binary.Decoder, o *GlUniform1fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform1fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1fv) ID() binary.ID      { return binaryIDGlUniform1fv }
func (*binaryClassGlUniform1fv) New() binary.Object { return &GlUniform1fv{} }
func (*binaryClassGlUniform1fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1fv(e, obj.(*GlUniform1fv))
}
func (*binaryClassGlUniform1fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1fv{}
	return obj, doDecodeGlUniform1fv(d, obj)
}
func (*binaryClassGlUniform1fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1fv(d, obj.(*GlUniform1fv))
}
func (*binaryClassGlUniform1fv) Skip(d binary.Decoder) error { return doSkipGlUniform1fv(d) }
func (*binaryClassGlUniform1fv) Schema() *schema.Class       { return schemaGlUniform1fv }

var schemaGlUniform1fv = &schema.Class{
	TypeID:  binaryIDGlUniform1fv,
	Package: "gles",
	Name:    "GlUniform1fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform1i struct{}

func (*GlUniform1i) Class() binary.Class {
	return (*binaryClassGlUniform1i)(nil)
}
func doEncodeGlUniform1i(e binary.Encoder, o *GlUniform1i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1i(d binary.Decoder, o *GlUniform1i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value = GLint(obj)
	}
	return nil
}
func doSkipGlUniform1i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1i) ID() binary.ID      { return binaryIDGlUniform1i }
func (*binaryClassGlUniform1i) New() binary.Object { return &GlUniform1i{} }
func (*binaryClassGlUniform1i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1i(e, obj.(*GlUniform1i))
}
func (*binaryClassGlUniform1i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1i{}
	return obj, doDecodeGlUniform1i(d, obj)
}
func (*binaryClassGlUniform1i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1i(d, obj.(*GlUniform1i))
}
func (*binaryClassGlUniform1i) Skip(d binary.Decoder) error { return doSkipGlUniform1i(d) }
func (*binaryClassGlUniform1i) Schema() *schema.Class       { return schemaGlUniform1i }

var schemaGlUniform1i = &schema.Class{
	TypeID:  binaryIDGlUniform1i,
	Package: "gles",
	Name:    "GlUniform1i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlUniform1iv struct{}

func (*GlUniform1iv) Class() binary.Class {
	return (*binaryClassGlUniform1iv)(nil)
}
func doEncodeGlUniform1iv(e binary.Encoder, o *GlUniform1iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1iv(d binary.Decoder, o *GlUniform1iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform1iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1iv) ID() binary.ID      { return binaryIDGlUniform1iv }
func (*binaryClassGlUniform1iv) New() binary.Object { return &GlUniform1iv{} }
func (*binaryClassGlUniform1iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1iv(e, obj.(*GlUniform1iv))
}
func (*binaryClassGlUniform1iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1iv{}
	return obj, doDecodeGlUniform1iv(d, obj)
}
func (*binaryClassGlUniform1iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1iv(d, obj.(*GlUniform1iv))
}
func (*binaryClassGlUniform1iv) Skip(d binary.Decoder) error { return doSkipGlUniform1iv(d) }
func (*binaryClassGlUniform1iv) Schema() *schema.Class       { return schemaGlUniform1iv }

var schemaGlUniform1iv = &schema.Class{
	TypeID:  binaryIDGlUniform1iv,
	Package: "gles",
	Name:    "GlUniform1iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform1ui struct{}

func (*GlUniform1ui) Class() binary.Class {
	return (*binaryClassGlUniform1ui)(nil)
}
func doEncodeGlUniform1ui(e binary.Encoder, o *GlUniform1ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1ui(d binary.Decoder, o *GlUniform1ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	return nil
}
func doSkipGlUniform1ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1ui) ID() binary.ID      { return binaryIDGlUniform1ui }
func (*binaryClassGlUniform1ui) New() binary.Object { return &GlUniform1ui{} }
func (*binaryClassGlUniform1ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1ui(e, obj.(*GlUniform1ui))
}
func (*binaryClassGlUniform1ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1ui{}
	return obj, doDecodeGlUniform1ui(d, obj)
}
func (*binaryClassGlUniform1ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1ui(d, obj.(*GlUniform1ui))
}
func (*binaryClassGlUniform1ui) Skip(d binary.Decoder) error { return doSkipGlUniform1ui(d) }
func (*binaryClassGlUniform1ui) Schema() *schema.Class       { return schemaGlUniform1ui }

var schemaGlUniform1ui = &schema.Class{
	TypeID:  binaryIDGlUniform1ui,
	Package: "gles",
	Name:    "GlUniform1ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlUniform1uiv struct{}

func (*GlUniform1uiv) Class() binary.Class {
	return (*binaryClassGlUniform1uiv)(nil)
}
func doEncodeGlUniform1uiv(e binary.Encoder, o *GlUniform1uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform1uiv(d binary.Decoder, o *GlUniform1uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform1uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform1uiv) ID() binary.ID      { return binaryIDGlUniform1uiv }
func (*binaryClassGlUniform1uiv) New() binary.Object { return &GlUniform1uiv{} }
func (*binaryClassGlUniform1uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform1uiv(e, obj.(*GlUniform1uiv))
}
func (*binaryClassGlUniform1uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform1uiv{}
	return obj, doDecodeGlUniform1uiv(d, obj)
}
func (*binaryClassGlUniform1uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform1uiv(d, obj.(*GlUniform1uiv))
}
func (*binaryClassGlUniform1uiv) Skip(d binary.Decoder) error { return doSkipGlUniform1uiv(d) }
func (*binaryClassGlUniform1uiv) Schema() *schema.Class       { return schemaGlUniform1uiv }

var schemaGlUniform1uiv = &schema.Class{
	TypeID:  binaryIDGlUniform1uiv,
	Package: "gles",
	Name:    "GlUniform1uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform2f struct{}

func (*GlUniform2f) Class() binary.Class {
	return (*binaryClassGlUniform2f)(nil)
}
func doEncodeGlUniform2f(e binary.Encoder, o *GlUniform2f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2f(d binary.Decoder, o *GlUniform2f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	return nil
}
func doSkipGlUniform2f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2f) ID() binary.ID      { return binaryIDGlUniform2f }
func (*binaryClassGlUniform2f) New() binary.Object { return &GlUniform2f{} }
func (*binaryClassGlUniform2f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2f(e, obj.(*GlUniform2f))
}
func (*binaryClassGlUniform2f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2f{}
	return obj, doDecodeGlUniform2f(d, obj)
}
func (*binaryClassGlUniform2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2f(d, obj.(*GlUniform2f))
}
func (*binaryClassGlUniform2f) Skip(d binary.Decoder) error { return doSkipGlUniform2f(d) }
func (*binaryClassGlUniform2f) Schema() *schema.Class       { return schemaGlUniform2f }

var schemaGlUniform2f = &schema.Class{
	TypeID:  binaryIDGlUniform2f,
	Package: "gles",
	Name:    "GlUniform2f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlUniform2fv struct{}

func (*GlUniform2fv) Class() binary.Class {
	return (*binaryClassGlUniform2fv)(nil)
}
func doEncodeGlUniform2fv(e binary.Encoder, o *GlUniform2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2fv(d binary.Decoder, o *GlUniform2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2fv) ID() binary.ID      { return binaryIDGlUniform2fv }
func (*binaryClassGlUniform2fv) New() binary.Object { return &GlUniform2fv{} }
func (*binaryClassGlUniform2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2fv(e, obj.(*GlUniform2fv))
}
func (*binaryClassGlUniform2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2fv{}
	return obj, doDecodeGlUniform2fv(d, obj)
}
func (*binaryClassGlUniform2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2fv(d, obj.(*GlUniform2fv))
}
func (*binaryClassGlUniform2fv) Skip(d binary.Decoder) error { return doSkipGlUniform2fv(d) }
func (*binaryClassGlUniform2fv) Schema() *schema.Class       { return schemaGlUniform2fv }

var schemaGlUniform2fv = &schema.Class{
	TypeID:  binaryIDGlUniform2fv,
	Package: "gles",
	Name:    "GlUniform2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform2i struct{}

func (*GlUniform2i) Class() binary.Class {
	return (*binaryClassGlUniform2i)(nil)
}
func doEncodeGlUniform2i(e binary.Encoder, o *GlUniform2i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2i(d binary.Decoder, o *GlUniform2i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value1 = GLint(obj)
	}
	return nil
}
func doSkipGlUniform2i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2i) ID() binary.ID      { return binaryIDGlUniform2i }
func (*binaryClassGlUniform2i) New() binary.Object { return &GlUniform2i{} }
func (*binaryClassGlUniform2i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2i(e, obj.(*GlUniform2i))
}
func (*binaryClassGlUniform2i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2i{}
	return obj, doDecodeGlUniform2i(d, obj)
}
func (*binaryClassGlUniform2i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2i(d, obj.(*GlUniform2i))
}
func (*binaryClassGlUniform2i) Skip(d binary.Decoder) error { return doSkipGlUniform2i(d) }
func (*binaryClassGlUniform2i) Schema() *schema.Class       { return schemaGlUniform2i }

var schemaGlUniform2i = &schema.Class{
	TypeID:  binaryIDGlUniform2i,
	Package: "gles",
	Name:    "GlUniform2i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlUniform2iv struct{}

func (*GlUniform2iv) Class() binary.Class {
	return (*binaryClassGlUniform2iv)(nil)
}
func doEncodeGlUniform2iv(e binary.Encoder, o *GlUniform2iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2iv(d binary.Decoder, o *GlUniform2iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform2iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2iv) ID() binary.ID      { return binaryIDGlUniform2iv }
func (*binaryClassGlUniform2iv) New() binary.Object { return &GlUniform2iv{} }
func (*binaryClassGlUniform2iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2iv(e, obj.(*GlUniform2iv))
}
func (*binaryClassGlUniform2iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2iv{}
	return obj, doDecodeGlUniform2iv(d, obj)
}
func (*binaryClassGlUniform2iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2iv(d, obj.(*GlUniform2iv))
}
func (*binaryClassGlUniform2iv) Skip(d binary.Decoder) error { return doSkipGlUniform2iv(d) }
func (*binaryClassGlUniform2iv) Schema() *schema.Class       { return schemaGlUniform2iv }

var schemaGlUniform2iv = &schema.Class{
	TypeID:  binaryIDGlUniform2iv,
	Package: "gles",
	Name:    "GlUniform2iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform2ui struct{}

func (*GlUniform2ui) Class() binary.Class {
	return (*binaryClassGlUniform2ui)(nil)
}
func doEncodeGlUniform2ui(e binary.Encoder, o *GlUniform2ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2ui(d binary.Decoder, o *GlUniform2ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	return nil
}
func doSkipGlUniform2ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2ui) ID() binary.ID      { return binaryIDGlUniform2ui }
func (*binaryClassGlUniform2ui) New() binary.Object { return &GlUniform2ui{} }
func (*binaryClassGlUniform2ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2ui(e, obj.(*GlUniform2ui))
}
func (*binaryClassGlUniform2ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2ui{}
	return obj, doDecodeGlUniform2ui(d, obj)
}
func (*binaryClassGlUniform2ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2ui(d, obj.(*GlUniform2ui))
}
func (*binaryClassGlUniform2ui) Skip(d binary.Decoder) error { return doSkipGlUniform2ui(d) }
func (*binaryClassGlUniform2ui) Schema() *schema.Class       { return schemaGlUniform2ui }

var schemaGlUniform2ui = &schema.Class{
	TypeID:  binaryIDGlUniform2ui,
	Package: "gles",
	Name:    "GlUniform2ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlUniform2uiv struct{}

func (*GlUniform2uiv) Class() binary.Class {
	return (*binaryClassGlUniform2uiv)(nil)
}
func doEncodeGlUniform2uiv(e binary.Encoder, o *GlUniform2uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform2uiv(d binary.Decoder, o *GlUniform2uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform2uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform2uiv) ID() binary.ID      { return binaryIDGlUniform2uiv }
func (*binaryClassGlUniform2uiv) New() binary.Object { return &GlUniform2uiv{} }
func (*binaryClassGlUniform2uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform2uiv(e, obj.(*GlUniform2uiv))
}
func (*binaryClassGlUniform2uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform2uiv{}
	return obj, doDecodeGlUniform2uiv(d, obj)
}
func (*binaryClassGlUniform2uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform2uiv(d, obj.(*GlUniform2uiv))
}
func (*binaryClassGlUniform2uiv) Skip(d binary.Decoder) error { return doSkipGlUniform2uiv(d) }
func (*binaryClassGlUniform2uiv) Schema() *schema.Class       { return schemaGlUniform2uiv }

var schemaGlUniform2uiv = &schema.Class{
	TypeID:  binaryIDGlUniform2uiv,
	Package: "gles",
	Name:    "GlUniform2uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform3f struct{}

func (*GlUniform3f) Class() binary.Class {
	return (*binaryClassGlUniform3f)(nil)
}
func doEncodeGlUniform3f(e binary.Encoder, o *GlUniform3f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3f(d binary.Decoder, o *GlUniform3f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value2 = GLfloat(obj)
	}
	return nil
}
func doSkipGlUniform3f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3f) ID() binary.ID      { return binaryIDGlUniform3f }
func (*binaryClassGlUniform3f) New() binary.Object { return &GlUniform3f{} }
func (*binaryClassGlUniform3f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3f(e, obj.(*GlUniform3f))
}
func (*binaryClassGlUniform3f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3f{}
	return obj, doDecodeGlUniform3f(d, obj)
}
func (*binaryClassGlUniform3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3f(d, obj.(*GlUniform3f))
}
func (*binaryClassGlUniform3f) Skip(d binary.Decoder) error { return doSkipGlUniform3f(d) }
func (*binaryClassGlUniform3f) Schema() *schema.Class       { return schemaGlUniform3f }

var schemaGlUniform3f = &schema.Class{
	TypeID:  binaryIDGlUniform3f,
	Package: "gles",
	Name:    "GlUniform3f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlUniform3fv struct{}

func (*GlUniform3fv) Class() binary.Class {
	return (*binaryClassGlUniform3fv)(nil)
}
func doEncodeGlUniform3fv(e binary.Encoder, o *GlUniform3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3fv(d binary.Decoder, o *GlUniform3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3fv) ID() binary.ID      { return binaryIDGlUniform3fv }
func (*binaryClassGlUniform3fv) New() binary.Object { return &GlUniform3fv{} }
func (*binaryClassGlUniform3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3fv(e, obj.(*GlUniform3fv))
}
func (*binaryClassGlUniform3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3fv{}
	return obj, doDecodeGlUniform3fv(d, obj)
}
func (*binaryClassGlUniform3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3fv(d, obj.(*GlUniform3fv))
}
func (*binaryClassGlUniform3fv) Skip(d binary.Decoder) error { return doSkipGlUniform3fv(d) }
func (*binaryClassGlUniform3fv) Schema() *schema.Class       { return schemaGlUniform3fv }

var schemaGlUniform3fv = &schema.Class{
	TypeID:  binaryIDGlUniform3fv,
	Package: "gles",
	Name:    "GlUniform3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform3i struct{}

func (*GlUniform3i) Class() binary.Class {
	return (*binaryClassGlUniform3i)(nil)
}
func doEncodeGlUniform3i(e binary.Encoder, o *GlUniform3i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3i(d binary.Decoder, o *GlUniform3i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value2 = GLint(obj)
	}
	return nil
}
func doSkipGlUniform3i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3i) ID() binary.ID      { return binaryIDGlUniform3i }
func (*binaryClassGlUniform3i) New() binary.Object { return &GlUniform3i{} }
func (*binaryClassGlUniform3i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3i(e, obj.(*GlUniform3i))
}
func (*binaryClassGlUniform3i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3i{}
	return obj, doDecodeGlUniform3i(d, obj)
}
func (*binaryClassGlUniform3i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3i(d, obj.(*GlUniform3i))
}
func (*binaryClassGlUniform3i) Skip(d binary.Decoder) error { return doSkipGlUniform3i(d) }
func (*binaryClassGlUniform3i) Schema() *schema.Class       { return schemaGlUniform3i }

var schemaGlUniform3i = &schema.Class{
	TypeID:  binaryIDGlUniform3i,
	Package: "gles",
	Name:    "GlUniform3i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlUniform3iv struct{}

func (*GlUniform3iv) Class() binary.Class {
	return (*binaryClassGlUniform3iv)(nil)
}
func doEncodeGlUniform3iv(e binary.Encoder, o *GlUniform3iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3iv(d binary.Decoder, o *GlUniform3iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform3iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3iv) ID() binary.ID      { return binaryIDGlUniform3iv }
func (*binaryClassGlUniform3iv) New() binary.Object { return &GlUniform3iv{} }
func (*binaryClassGlUniform3iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3iv(e, obj.(*GlUniform3iv))
}
func (*binaryClassGlUniform3iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3iv{}
	return obj, doDecodeGlUniform3iv(d, obj)
}
func (*binaryClassGlUniform3iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3iv(d, obj.(*GlUniform3iv))
}
func (*binaryClassGlUniform3iv) Skip(d binary.Decoder) error { return doSkipGlUniform3iv(d) }
func (*binaryClassGlUniform3iv) Schema() *schema.Class       { return schemaGlUniform3iv }

var schemaGlUniform3iv = &schema.Class{
	TypeID:  binaryIDGlUniform3iv,
	Package: "gles",
	Name:    "GlUniform3iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform3ui struct{}

func (*GlUniform3ui) Class() binary.Class {
	return (*binaryClassGlUniform3ui)(nil)
}
func doEncodeGlUniform3ui(e binary.Encoder, o *GlUniform3ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3ui(d binary.Decoder, o *GlUniform3ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	return nil
}
func doSkipGlUniform3ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3ui) ID() binary.ID      { return binaryIDGlUniform3ui }
func (*binaryClassGlUniform3ui) New() binary.Object { return &GlUniform3ui{} }
func (*binaryClassGlUniform3ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3ui(e, obj.(*GlUniform3ui))
}
func (*binaryClassGlUniform3ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3ui{}
	return obj, doDecodeGlUniform3ui(d, obj)
}
func (*binaryClassGlUniform3ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3ui(d, obj.(*GlUniform3ui))
}
func (*binaryClassGlUniform3ui) Skip(d binary.Decoder) error { return doSkipGlUniform3ui(d) }
func (*binaryClassGlUniform3ui) Schema() *schema.Class       { return schemaGlUniform3ui }

var schemaGlUniform3ui = &schema.Class{
	TypeID:  binaryIDGlUniform3ui,
	Package: "gles",
	Name:    "GlUniform3ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlUniform3uiv struct{}

func (*GlUniform3uiv) Class() binary.Class {
	return (*binaryClassGlUniform3uiv)(nil)
}
func doEncodeGlUniform3uiv(e binary.Encoder, o *GlUniform3uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform3uiv(d binary.Decoder, o *GlUniform3uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform3uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform3uiv) ID() binary.ID      { return binaryIDGlUniform3uiv }
func (*binaryClassGlUniform3uiv) New() binary.Object { return &GlUniform3uiv{} }
func (*binaryClassGlUniform3uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform3uiv(e, obj.(*GlUniform3uiv))
}
func (*binaryClassGlUniform3uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform3uiv{}
	return obj, doDecodeGlUniform3uiv(d, obj)
}
func (*binaryClassGlUniform3uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform3uiv(d, obj.(*GlUniform3uiv))
}
func (*binaryClassGlUniform3uiv) Skip(d binary.Decoder) error { return doSkipGlUniform3uiv(d) }
func (*binaryClassGlUniform3uiv) Schema() *schema.Class       { return schemaGlUniform3uiv }

var schemaGlUniform3uiv = &schema.Class{
	TypeID:  binaryIDGlUniform3uiv,
	Package: "gles",
	Name:    "GlUniform3uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform4f struct{}

func (*GlUniform4f) Class() binary.Class {
	return (*binaryClassGlUniform4f)(nil)
}
func doEncodeGlUniform4f(e binary.Encoder, o *GlUniform4f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value2)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4f(d binary.Decoder, o *GlUniform4f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value2 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value3 = GLfloat(obj)
	}
	return nil
}
func doSkipGlUniform4f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4f) ID() binary.ID      { return binaryIDGlUniform4f }
func (*binaryClassGlUniform4f) New() binary.Object { return &GlUniform4f{} }
func (*binaryClassGlUniform4f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4f(e, obj.(*GlUniform4f))
}
func (*binaryClassGlUniform4f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4f{}
	return obj, doDecodeGlUniform4f(d, obj)
}
func (*binaryClassGlUniform4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4f(d, obj.(*GlUniform4f))
}
func (*binaryClassGlUniform4f) Skip(d binary.Decoder) error { return doSkipGlUniform4f(d) }
func (*binaryClassGlUniform4f) Schema() *schema.Class       { return schemaGlUniform4f }

var schemaGlUniform4f = &schema.Class{
	TypeID:  binaryIDGlUniform4f,
	Package: "gles",
	Name:    "GlUniform4f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value3", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlUniform4fv struct{}

func (*GlUniform4fv) Class() binary.Class {
	return (*binaryClassGlUniform4fv)(nil)
}
func doEncodeGlUniform4fv(e binary.Encoder, o *GlUniform4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4fv(d binary.Decoder, o *GlUniform4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4fv) ID() binary.ID      { return binaryIDGlUniform4fv }
func (*binaryClassGlUniform4fv) New() binary.Object { return &GlUniform4fv{} }
func (*binaryClassGlUniform4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4fv(e, obj.(*GlUniform4fv))
}
func (*binaryClassGlUniform4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4fv{}
	return obj, doDecodeGlUniform4fv(d, obj)
}
func (*binaryClassGlUniform4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4fv(d, obj.(*GlUniform4fv))
}
func (*binaryClassGlUniform4fv) Skip(d binary.Decoder) error { return doSkipGlUniform4fv(d) }
func (*binaryClassGlUniform4fv) Schema() *schema.Class       { return schemaGlUniform4fv }

var schemaGlUniform4fv = &schema.Class{
	TypeID:  binaryIDGlUniform4fv,
	Package: "gles",
	Name:    "GlUniform4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform4i struct{}

func (*GlUniform4i) Class() binary.Class {
	return (*binaryClassGlUniform4i)(nil)
}
func doEncodeGlUniform4i(e binary.Encoder, o *GlUniform4i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value0)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value1)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value2)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Value3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4i(d binary.Decoder, o *GlUniform4i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value0 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value1 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value2 = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Value3 = GLint(obj)
	}
	return nil
}
func doSkipGlUniform4i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4i) ID() binary.ID      { return binaryIDGlUniform4i }
func (*binaryClassGlUniform4i) New() binary.Object { return &GlUniform4i{} }
func (*binaryClassGlUniform4i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4i(e, obj.(*GlUniform4i))
}
func (*binaryClassGlUniform4i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4i{}
	return obj, doDecodeGlUniform4i(d, obj)
}
func (*binaryClassGlUniform4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4i(d, obj.(*GlUniform4i))
}
func (*binaryClassGlUniform4i) Skip(d binary.Decoder) error { return doSkipGlUniform4i(d) }
func (*binaryClassGlUniform4i) Schema() *schema.Class       { return schemaGlUniform4i }

var schemaGlUniform4i = &schema.Class{
	TypeID:  binaryIDGlUniform4i,
	Package: "gles",
	Name:    "GlUniform4i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Value3", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlUniform4iv struct{}

func (*GlUniform4iv) Class() binary.Class {
	return (*binaryClassGlUniform4iv)(nil)
}
func doEncodeGlUniform4iv(e binary.Encoder, o *GlUniform4iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4iv(d binary.Decoder, o *GlUniform4iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform4iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4iv) ID() binary.ID      { return binaryIDGlUniform4iv }
func (*binaryClassGlUniform4iv) New() binary.Object { return &GlUniform4iv{} }
func (*binaryClassGlUniform4iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4iv(e, obj.(*GlUniform4iv))
}
func (*binaryClassGlUniform4iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4iv{}
	return obj, doDecodeGlUniform4iv(d, obj)
}
func (*binaryClassGlUniform4iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4iv(d, obj.(*GlUniform4iv))
}
func (*binaryClassGlUniform4iv) Skip(d binary.Decoder) error { return doSkipGlUniform4iv(d) }
func (*binaryClassGlUniform4iv) Schema() *schema.Class       { return schemaGlUniform4iv }

var schemaGlUniform4iv = &schema.Class{
	TypeID:  binaryIDGlUniform4iv,
	Package: "gles",
	Name:    "GlUniform4iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniform4ui struct{}

func (*GlUniform4ui) Class() binary.Class {
	return (*binaryClassGlUniform4ui)(nil)
}
func doEncodeGlUniform4ui(e binary.Encoder, o *GlUniform4ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V0)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V1)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V2)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.V3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4ui(d binary.Decoder, o *GlUniform4ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V0 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V1 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V2 = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.V3 = GLuint(obj)
	}
	return nil
}
func doSkipGlUniform4ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4ui) ID() binary.ID      { return binaryIDGlUniform4ui }
func (*binaryClassGlUniform4ui) New() binary.Object { return &GlUniform4ui{} }
func (*binaryClassGlUniform4ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4ui(e, obj.(*GlUniform4ui))
}
func (*binaryClassGlUniform4ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4ui{}
	return obj, doDecodeGlUniform4ui(d, obj)
}
func (*binaryClassGlUniform4ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4ui(d, obj.(*GlUniform4ui))
}
func (*binaryClassGlUniform4ui) Skip(d binary.Decoder) error { return doSkipGlUniform4ui(d) }
func (*binaryClassGlUniform4ui) Schema() *schema.Class       { return schemaGlUniform4ui }

var schemaGlUniform4ui = &schema.Class{
	TypeID:  binaryIDGlUniform4ui,
	Package: "gles",
	Name:    "GlUniform4ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "V0", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V1", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V2", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V3", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlUniform4uiv struct{}

func (*GlUniform4uiv) Class() binary.Class {
	return (*binaryClassGlUniform4uiv)(nil)
}
func doEncodeGlUniform4uiv(e binary.Encoder, o *GlUniform4uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniform4uiv(d binary.Decoder, o *GlUniform4uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniform4uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniform4uiv) ID() binary.ID      { return binaryIDGlUniform4uiv }
func (*binaryClassGlUniform4uiv) New() binary.Object { return &GlUniform4uiv{} }
func (*binaryClassGlUniform4uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniform4uiv(e, obj.(*GlUniform4uiv))
}
func (*binaryClassGlUniform4uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniform4uiv{}
	return obj, doDecodeGlUniform4uiv(d, obj)
}
func (*binaryClassGlUniform4uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniform4uiv(d, obj.(*GlUniform4uiv))
}
func (*binaryClassGlUniform4uiv) Skip(d binary.Decoder) error { return doSkipGlUniform4uiv(d) }
func (*binaryClassGlUniform4uiv) Schema() *schema.Class       { return schemaGlUniform4uiv }

var schemaGlUniform4uiv = &schema.Class{
	TypeID:  binaryIDGlUniform4uiv,
	Package: "gles",
	Name:    "GlUniform4uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformBlockBinding struct{}

func (*GlUniformBlockBinding) Class() binary.Class {
	return (*binaryClassGlUniformBlockBinding)(nil)
}
func doEncodeGlUniformBlockBinding(e binary.Encoder, o *GlUniformBlockBinding) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.UniformBlockIndex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.UniformBlockBinding)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformBlockBinding(d binary.Decoder, o *GlUniformBlockBinding) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.UniformBlockIndex = UniformBlockId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.UniformBlockBinding = GLuint(obj)
	}
	return nil
}
func doSkipGlUniformBlockBinding(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformBlockBinding) ID() binary.ID      { return binaryIDGlUniformBlockBinding }
func (*binaryClassGlUniformBlockBinding) New() binary.Object { return &GlUniformBlockBinding{} }
func (*binaryClassGlUniformBlockBinding) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformBlockBinding(e, obj.(*GlUniformBlockBinding))
}
func (*binaryClassGlUniformBlockBinding) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformBlockBinding{}
	return obj, doDecodeGlUniformBlockBinding(d, obj)
}
func (*binaryClassGlUniformBlockBinding) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformBlockBinding(d, obj.(*GlUniformBlockBinding))
}
func (*binaryClassGlUniformBlockBinding) Skip(d binary.Decoder) error {
	return doSkipGlUniformBlockBinding(d)
}
func (*binaryClassGlUniformBlockBinding) Schema() *schema.Class { return schemaGlUniformBlockBinding }

var schemaGlUniformBlockBinding = &schema.Class{
	TypeID:  binaryIDGlUniformBlockBinding,
	Package: "gles",
	Name:    "GlUniformBlockBinding",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
		{Declared: "UniformBlockIndex", Type: &schema.Primitive{Name: "UniformBlockId", Method: schema.Uint32}},
		{Declared: "UniformBlockBinding", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlUniformHandleui64NV struct{}

func (*GlUniformHandleui64NV) Class() binary.Class {
	return (*binaryClassGlUniformHandleui64NV)(nil)
}
func doEncodeGlUniformHandleui64NV(e binary.Encoder, o *GlUniformHandleui64NV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Value)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformHandleui64NV(d binary.Decoder, o *GlUniformHandleui64NV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Value = GLuint64(obj)
	}
	return nil
}
func doSkipGlUniformHandleui64NV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformHandleui64NV) ID() binary.ID      { return binaryIDGlUniformHandleui64NV }
func (*binaryClassGlUniformHandleui64NV) New() binary.Object { return &GlUniformHandleui64NV{} }
func (*binaryClassGlUniformHandleui64NV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformHandleui64NV(e, obj.(*GlUniformHandleui64NV))
}
func (*binaryClassGlUniformHandleui64NV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformHandleui64NV{}
	return obj, doDecodeGlUniformHandleui64NV(d, obj)
}
func (*binaryClassGlUniformHandleui64NV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformHandleui64NV(d, obj.(*GlUniformHandleui64NV))
}
func (*binaryClassGlUniformHandleui64NV) Skip(d binary.Decoder) error {
	return doSkipGlUniformHandleui64NV(d)
}
func (*binaryClassGlUniformHandleui64NV) Schema() *schema.Class { return schemaGlUniformHandleui64NV }

var schemaGlUniformHandleui64NV = &schema.Class{
	TypeID:  binaryIDGlUniformHandleui64NV,
	Package: "gles",
	Name:    "GlUniformHandleui64NV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlUniformHandleui64vNV struct{}

func (*GlUniformHandleui64vNV) Class() binary.Class {
	return (*binaryClassGlUniformHandleui64vNV)(nil)
}
func doEncodeGlUniformHandleui64vNV(e binary.Encoder, o *GlUniformHandleui64vNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformHandleui64vNV(d binary.Decoder, o *GlUniformHandleui64vNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformHandleui64vNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuint64ᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformHandleui64vNV) ID() binary.ID      { return binaryIDGlUniformHandleui64vNV }
func (*binaryClassGlUniformHandleui64vNV) New() binary.Object { return &GlUniformHandleui64vNV{} }
func (*binaryClassGlUniformHandleui64vNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformHandleui64vNV(e, obj.(*GlUniformHandleui64vNV))
}
func (*binaryClassGlUniformHandleui64vNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformHandleui64vNV{}
	return obj, doDecodeGlUniformHandleui64vNV(d, obj)
}
func (*binaryClassGlUniformHandleui64vNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformHandleui64vNV(d, obj.(*GlUniformHandleui64vNV))
}
func (*binaryClassGlUniformHandleui64vNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformHandleui64vNV(d)
}
func (*binaryClassGlUniformHandleui64vNV) Schema() *schema.Class { return schemaGlUniformHandleui64vNV }

var schemaGlUniformHandleui64vNV = &schema.Class{
	TypeID:  binaryIDGlUniformHandleui64vNV,
	Package: "gles",
	Name:    "GlUniformHandleui64vNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLuint64ᶜᵖ", ID: (*GLuint64ᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix2fv struct{}

func (*GlUniformMatrix2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2fv)(nil)
}
func doEncodeGlUniformMatrix2fv(e binary.Encoder, o *GlUniformMatrix2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix2fv(d binary.Decoder, o *GlUniformMatrix2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix2fv) ID() binary.ID      { return binaryIDGlUniformMatrix2fv }
func (*binaryClassGlUniformMatrix2fv) New() binary.Object { return &GlUniformMatrix2fv{} }
func (*binaryClassGlUniformMatrix2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix2fv(e, obj.(*GlUniformMatrix2fv))
}
func (*binaryClassGlUniformMatrix2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix2fv{}
	return obj, doDecodeGlUniformMatrix2fv(d, obj)
}
func (*binaryClassGlUniformMatrix2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix2fv(d, obj.(*GlUniformMatrix2fv))
}
func (*binaryClassGlUniformMatrix2fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix2fv(d) }
func (*binaryClassGlUniformMatrix2fv) Schema() *schema.Class       { return schemaGlUniformMatrix2fv }

var schemaGlUniformMatrix2fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix2fv,
	Package: "gles",
	Name:    "GlUniformMatrix2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix2x3fv struct{}

func (*GlUniformMatrix2x3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x3fv)(nil)
}
func doEncodeGlUniformMatrix2x3fv(e binary.Encoder, o *GlUniformMatrix2x3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix2x3fv(d binary.Decoder, o *GlUniformMatrix2x3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix2x3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix2x3fv) ID() binary.ID      { return binaryIDGlUniformMatrix2x3fv }
func (*binaryClassGlUniformMatrix2x3fv) New() binary.Object { return &GlUniformMatrix2x3fv{} }
func (*binaryClassGlUniformMatrix2x3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix2x3fv(e, obj.(*GlUniformMatrix2x3fv))
}
func (*binaryClassGlUniformMatrix2x3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix2x3fv{}
	return obj, doDecodeGlUniformMatrix2x3fv(d, obj)
}
func (*binaryClassGlUniformMatrix2x3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix2x3fv(d, obj.(*GlUniformMatrix2x3fv))
}
func (*binaryClassGlUniformMatrix2x3fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix2x3fv(d)
}
func (*binaryClassGlUniformMatrix2x3fv) Schema() *schema.Class { return schemaGlUniformMatrix2x3fv }

var schemaGlUniformMatrix2x3fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix2x3fv,
	Package: "gles",
	Name:    "GlUniformMatrix2x3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix2x3fvNV struct{}

func (*GlUniformMatrix2x3fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x3fvNV)(nil)
}
func doEncodeGlUniformMatrix2x3fvNV(e binary.Encoder, o *GlUniformMatrix2x3fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix2x3fvNV(d binary.Decoder, o *GlUniformMatrix2x3fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix2x3fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix2x3fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix2x3fvNV }
func (*binaryClassGlUniformMatrix2x3fvNV) New() binary.Object { return &GlUniformMatrix2x3fvNV{} }
func (*binaryClassGlUniformMatrix2x3fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix2x3fvNV(e, obj.(*GlUniformMatrix2x3fvNV))
}
func (*binaryClassGlUniformMatrix2x3fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix2x3fvNV{}
	return obj, doDecodeGlUniformMatrix2x3fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix2x3fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix2x3fvNV(d, obj.(*GlUniformMatrix2x3fvNV))
}
func (*binaryClassGlUniformMatrix2x3fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix2x3fvNV(d)
}
func (*binaryClassGlUniformMatrix2x3fvNV) Schema() *schema.Class { return schemaGlUniformMatrix2x3fvNV }

var schemaGlUniformMatrix2x3fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix2x3fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix2x3fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix2x4fv struct{}

func (*GlUniformMatrix2x4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x4fv)(nil)
}
func doEncodeGlUniformMatrix2x4fv(e binary.Encoder, o *GlUniformMatrix2x4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix2x4fv(d binary.Decoder, o *GlUniformMatrix2x4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix2x4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix2x4fv) ID() binary.ID      { return binaryIDGlUniformMatrix2x4fv }
func (*binaryClassGlUniformMatrix2x4fv) New() binary.Object { return &GlUniformMatrix2x4fv{} }
func (*binaryClassGlUniformMatrix2x4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix2x4fv(e, obj.(*GlUniformMatrix2x4fv))
}
func (*binaryClassGlUniformMatrix2x4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix2x4fv{}
	return obj, doDecodeGlUniformMatrix2x4fv(d, obj)
}
func (*binaryClassGlUniformMatrix2x4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix2x4fv(d, obj.(*GlUniformMatrix2x4fv))
}
func (*binaryClassGlUniformMatrix2x4fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix2x4fv(d)
}
func (*binaryClassGlUniformMatrix2x4fv) Schema() *schema.Class { return schemaGlUniformMatrix2x4fv }

var schemaGlUniformMatrix2x4fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix2x4fv,
	Package: "gles",
	Name:    "GlUniformMatrix2x4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix2x4fvNV struct{}

func (*GlUniformMatrix2x4fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix2x4fvNV)(nil)
}
func doEncodeGlUniformMatrix2x4fvNV(e binary.Encoder, o *GlUniformMatrix2x4fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix2x4fvNV(d binary.Decoder, o *GlUniformMatrix2x4fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix2x4fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix2x4fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix2x4fvNV }
func (*binaryClassGlUniformMatrix2x4fvNV) New() binary.Object { return &GlUniformMatrix2x4fvNV{} }
func (*binaryClassGlUniformMatrix2x4fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix2x4fvNV(e, obj.(*GlUniformMatrix2x4fvNV))
}
func (*binaryClassGlUniformMatrix2x4fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix2x4fvNV{}
	return obj, doDecodeGlUniformMatrix2x4fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix2x4fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix2x4fvNV(d, obj.(*GlUniformMatrix2x4fvNV))
}
func (*binaryClassGlUniformMatrix2x4fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix2x4fvNV(d)
}
func (*binaryClassGlUniformMatrix2x4fvNV) Schema() *schema.Class { return schemaGlUniformMatrix2x4fvNV }

var schemaGlUniformMatrix2x4fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix2x4fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix2x4fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix3fv struct{}

func (*GlUniformMatrix3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3fv)(nil)
}
func doEncodeGlUniformMatrix3fv(e binary.Encoder, o *GlUniformMatrix3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix3fv(d binary.Decoder, o *GlUniformMatrix3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix3fv) ID() binary.ID      { return binaryIDGlUniformMatrix3fv }
func (*binaryClassGlUniformMatrix3fv) New() binary.Object { return &GlUniformMatrix3fv{} }
func (*binaryClassGlUniformMatrix3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix3fv(e, obj.(*GlUniformMatrix3fv))
}
func (*binaryClassGlUniformMatrix3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix3fv{}
	return obj, doDecodeGlUniformMatrix3fv(d, obj)
}
func (*binaryClassGlUniformMatrix3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix3fv(d, obj.(*GlUniformMatrix3fv))
}
func (*binaryClassGlUniformMatrix3fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix3fv(d) }
func (*binaryClassGlUniformMatrix3fv) Schema() *schema.Class       { return schemaGlUniformMatrix3fv }

var schemaGlUniformMatrix3fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix3fv,
	Package: "gles",
	Name:    "GlUniformMatrix3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix3x2fv struct{}

func (*GlUniformMatrix3x2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x2fv)(nil)
}
func doEncodeGlUniformMatrix3x2fv(e binary.Encoder, o *GlUniformMatrix3x2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix3x2fv(d binary.Decoder, o *GlUniformMatrix3x2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix3x2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix3x2fv) ID() binary.ID      { return binaryIDGlUniformMatrix3x2fv }
func (*binaryClassGlUniformMatrix3x2fv) New() binary.Object { return &GlUniformMatrix3x2fv{} }
func (*binaryClassGlUniformMatrix3x2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix3x2fv(e, obj.(*GlUniformMatrix3x2fv))
}
func (*binaryClassGlUniformMatrix3x2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix3x2fv{}
	return obj, doDecodeGlUniformMatrix3x2fv(d, obj)
}
func (*binaryClassGlUniformMatrix3x2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix3x2fv(d, obj.(*GlUniformMatrix3x2fv))
}
func (*binaryClassGlUniformMatrix3x2fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix3x2fv(d)
}
func (*binaryClassGlUniformMatrix3x2fv) Schema() *schema.Class { return schemaGlUniformMatrix3x2fv }

var schemaGlUniformMatrix3x2fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix3x2fv,
	Package: "gles",
	Name:    "GlUniformMatrix3x2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix3x2fvNV struct{}

func (*GlUniformMatrix3x2fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x2fvNV)(nil)
}
func doEncodeGlUniformMatrix3x2fvNV(e binary.Encoder, o *GlUniformMatrix3x2fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix3x2fvNV(d binary.Decoder, o *GlUniformMatrix3x2fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix3x2fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix3x2fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix3x2fvNV }
func (*binaryClassGlUniformMatrix3x2fvNV) New() binary.Object { return &GlUniformMatrix3x2fvNV{} }
func (*binaryClassGlUniformMatrix3x2fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix3x2fvNV(e, obj.(*GlUniformMatrix3x2fvNV))
}
func (*binaryClassGlUniformMatrix3x2fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix3x2fvNV{}
	return obj, doDecodeGlUniformMatrix3x2fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix3x2fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix3x2fvNV(d, obj.(*GlUniformMatrix3x2fvNV))
}
func (*binaryClassGlUniformMatrix3x2fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix3x2fvNV(d)
}
func (*binaryClassGlUniformMatrix3x2fvNV) Schema() *schema.Class { return schemaGlUniformMatrix3x2fvNV }

var schemaGlUniformMatrix3x2fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix3x2fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix3x2fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix3x4fv struct{}

func (*GlUniformMatrix3x4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x4fv)(nil)
}
func doEncodeGlUniformMatrix3x4fv(e binary.Encoder, o *GlUniformMatrix3x4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix3x4fv(d binary.Decoder, o *GlUniformMatrix3x4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix3x4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix3x4fv) ID() binary.ID      { return binaryIDGlUniformMatrix3x4fv }
func (*binaryClassGlUniformMatrix3x4fv) New() binary.Object { return &GlUniformMatrix3x4fv{} }
func (*binaryClassGlUniformMatrix3x4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix3x4fv(e, obj.(*GlUniformMatrix3x4fv))
}
func (*binaryClassGlUniformMatrix3x4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix3x4fv{}
	return obj, doDecodeGlUniformMatrix3x4fv(d, obj)
}
func (*binaryClassGlUniformMatrix3x4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix3x4fv(d, obj.(*GlUniformMatrix3x4fv))
}
func (*binaryClassGlUniformMatrix3x4fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix3x4fv(d)
}
func (*binaryClassGlUniformMatrix3x4fv) Schema() *schema.Class { return schemaGlUniformMatrix3x4fv }

var schemaGlUniformMatrix3x4fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix3x4fv,
	Package: "gles",
	Name:    "GlUniformMatrix3x4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix3x4fvNV struct{}

func (*GlUniformMatrix3x4fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix3x4fvNV)(nil)
}
func doEncodeGlUniformMatrix3x4fvNV(e binary.Encoder, o *GlUniformMatrix3x4fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix3x4fvNV(d binary.Decoder, o *GlUniformMatrix3x4fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix3x4fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix3x4fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix3x4fvNV }
func (*binaryClassGlUniformMatrix3x4fvNV) New() binary.Object { return &GlUniformMatrix3x4fvNV{} }
func (*binaryClassGlUniformMatrix3x4fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix3x4fvNV(e, obj.(*GlUniformMatrix3x4fvNV))
}
func (*binaryClassGlUniformMatrix3x4fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix3x4fvNV{}
	return obj, doDecodeGlUniformMatrix3x4fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix3x4fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix3x4fvNV(d, obj.(*GlUniformMatrix3x4fvNV))
}
func (*binaryClassGlUniformMatrix3x4fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix3x4fvNV(d)
}
func (*binaryClassGlUniformMatrix3x4fvNV) Schema() *schema.Class { return schemaGlUniformMatrix3x4fvNV }

var schemaGlUniformMatrix3x4fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix3x4fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix3x4fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix4fv struct{}

func (*GlUniformMatrix4fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4fv)(nil)
}
func doEncodeGlUniformMatrix4fv(e binary.Encoder, o *GlUniformMatrix4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix4fv(d binary.Decoder, o *GlUniformMatrix4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Values); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix4fv) ID() binary.ID      { return binaryIDGlUniformMatrix4fv }
func (*binaryClassGlUniformMatrix4fv) New() binary.Object { return &GlUniformMatrix4fv{} }
func (*binaryClassGlUniformMatrix4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix4fv(e, obj.(*GlUniformMatrix4fv))
}
func (*binaryClassGlUniformMatrix4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix4fv{}
	return obj, doDecodeGlUniformMatrix4fv(d, obj)
}
func (*binaryClassGlUniformMatrix4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix4fv(d, obj.(*GlUniformMatrix4fv))
}
func (*binaryClassGlUniformMatrix4fv) Skip(d binary.Decoder) error { return doSkipGlUniformMatrix4fv(d) }
func (*binaryClassGlUniformMatrix4fv) Schema() *schema.Class       { return schemaGlUniformMatrix4fv }

var schemaGlUniformMatrix4fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix4fv,
	Package: "gles",
	Name:    "GlUniformMatrix4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Values", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix4x2fv struct{}

func (*GlUniformMatrix4x2fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x2fv)(nil)
}
func doEncodeGlUniformMatrix4x2fv(e binary.Encoder, o *GlUniformMatrix4x2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix4x2fv(d binary.Decoder, o *GlUniformMatrix4x2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix4x2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix4x2fv) ID() binary.ID      { return binaryIDGlUniformMatrix4x2fv }
func (*binaryClassGlUniformMatrix4x2fv) New() binary.Object { return &GlUniformMatrix4x2fv{} }
func (*binaryClassGlUniformMatrix4x2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix4x2fv(e, obj.(*GlUniformMatrix4x2fv))
}
func (*binaryClassGlUniformMatrix4x2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix4x2fv{}
	return obj, doDecodeGlUniformMatrix4x2fv(d, obj)
}
func (*binaryClassGlUniformMatrix4x2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix4x2fv(d, obj.(*GlUniformMatrix4x2fv))
}
func (*binaryClassGlUniformMatrix4x2fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix4x2fv(d)
}
func (*binaryClassGlUniformMatrix4x2fv) Schema() *schema.Class { return schemaGlUniformMatrix4x2fv }

var schemaGlUniformMatrix4x2fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix4x2fv,
	Package: "gles",
	Name:    "GlUniformMatrix4x2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix4x2fvNV struct{}

func (*GlUniformMatrix4x2fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x2fvNV)(nil)
}
func doEncodeGlUniformMatrix4x2fvNV(e binary.Encoder, o *GlUniformMatrix4x2fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix4x2fvNV(d binary.Decoder, o *GlUniformMatrix4x2fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix4x2fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix4x2fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix4x2fvNV }
func (*binaryClassGlUniformMatrix4x2fvNV) New() binary.Object { return &GlUniformMatrix4x2fvNV{} }
func (*binaryClassGlUniformMatrix4x2fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix4x2fvNV(e, obj.(*GlUniformMatrix4x2fvNV))
}
func (*binaryClassGlUniformMatrix4x2fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix4x2fvNV{}
	return obj, doDecodeGlUniformMatrix4x2fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix4x2fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix4x2fvNV(d, obj.(*GlUniformMatrix4x2fvNV))
}
func (*binaryClassGlUniformMatrix4x2fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix4x2fvNV(d)
}
func (*binaryClassGlUniformMatrix4x2fvNV) Schema() *schema.Class { return schemaGlUniformMatrix4x2fvNV }

var schemaGlUniformMatrix4x2fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix4x2fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix4x2fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix4x3fv struct{}

func (*GlUniformMatrix4x3fv) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x3fv)(nil)
}
func doEncodeGlUniformMatrix4x3fv(e binary.Encoder, o *GlUniformMatrix4x3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix4x3fv(d binary.Decoder, o *GlUniformMatrix4x3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix4x3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix4x3fv) ID() binary.ID      { return binaryIDGlUniformMatrix4x3fv }
func (*binaryClassGlUniformMatrix4x3fv) New() binary.Object { return &GlUniformMatrix4x3fv{} }
func (*binaryClassGlUniformMatrix4x3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix4x3fv(e, obj.(*GlUniformMatrix4x3fv))
}
func (*binaryClassGlUniformMatrix4x3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix4x3fv{}
	return obj, doDecodeGlUniformMatrix4x3fv(d, obj)
}
func (*binaryClassGlUniformMatrix4x3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix4x3fv(d, obj.(*GlUniformMatrix4x3fv))
}
func (*binaryClassGlUniformMatrix4x3fv) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix4x3fv(d)
}
func (*binaryClassGlUniformMatrix4x3fv) Schema() *schema.Class { return schemaGlUniformMatrix4x3fv }

var schemaGlUniformMatrix4x3fv = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix4x3fv,
	Package: "gles",
	Name:    "GlUniformMatrix4x3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUniformMatrix4x3fvNV struct{}

func (*GlUniformMatrix4x3fvNV) Class() binary.Class {
	return (*binaryClassGlUniformMatrix4x3fvNV)(nil)
}
func doEncodeGlUniformMatrix4x3fvNV(e binary.Encoder, o *GlUniformMatrix4x3fvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Transpose)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUniformMatrix4x3fvNV(d binary.Decoder, o *GlUniformMatrix4x3fvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Location = UniformLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Transpose = GLboolean(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlUniformMatrix4x3fvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUniformMatrix4x3fvNV) ID() binary.ID      { return binaryIDGlUniformMatrix4x3fvNV }
func (*binaryClassGlUniformMatrix4x3fvNV) New() binary.Object { return &GlUniformMatrix4x3fvNV{} }
func (*binaryClassGlUniformMatrix4x3fvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUniformMatrix4x3fvNV(e, obj.(*GlUniformMatrix4x3fvNV))
}
func (*binaryClassGlUniformMatrix4x3fvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUniformMatrix4x3fvNV{}
	return obj, doDecodeGlUniformMatrix4x3fvNV(d, obj)
}
func (*binaryClassGlUniformMatrix4x3fvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUniformMatrix4x3fvNV(d, obj.(*GlUniformMatrix4x3fvNV))
}
func (*binaryClassGlUniformMatrix4x3fvNV) Skip(d binary.Decoder) error {
	return doSkipGlUniformMatrix4x3fvNV(d)
}
func (*binaryClassGlUniformMatrix4x3fvNV) Schema() *schema.Class { return schemaGlUniformMatrix4x3fvNV }

var schemaGlUniformMatrix4x3fvNV = &schema.Class{
	TypeID:  binaryIDGlUniformMatrix4x3fvNV,
	Package: "gles",
	Name:    "GlUniformMatrix4x3fvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "UniformLocation", Method: schema.Int32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Transpose", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlUnmapBuffer struct{}

func (*GlUnmapBuffer) Class() binary.Class {
	return (*binaryClassGlUnmapBuffer)(nil)
}
func doEncodeGlUnmapBuffer(e binary.Encoder, o *GlUnmapBuffer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUnmapBuffer(d binary.Decoder, o *GlUnmapBuffer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlUnmapBuffer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUnmapBuffer) ID() binary.ID      { return binaryIDGlUnmapBuffer }
func (*binaryClassGlUnmapBuffer) New() binary.Object { return &GlUnmapBuffer{} }
func (*binaryClassGlUnmapBuffer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUnmapBuffer(e, obj.(*GlUnmapBuffer))
}
func (*binaryClassGlUnmapBuffer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUnmapBuffer{}
	return obj, doDecodeGlUnmapBuffer(d, obj)
}
func (*binaryClassGlUnmapBuffer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUnmapBuffer(d, obj.(*GlUnmapBuffer))
}
func (*binaryClassGlUnmapBuffer) Skip(d binary.Decoder) error { return doSkipGlUnmapBuffer(d) }
func (*binaryClassGlUnmapBuffer) Schema() *schema.Class       { return schemaGlUnmapBuffer }

var schemaGlUnmapBuffer = &schema.Class{
	TypeID:  binaryIDGlUnmapBuffer,
	Package: "gles",
	Name:    "GlUnmapBuffer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlUnmapBufferOES struct{}

func (*GlUnmapBufferOES) Class() binary.Class {
	return (*binaryClassGlUnmapBufferOES)(nil)
}
func doEncodeGlUnmapBufferOES(e binary.Encoder, o *GlUnmapBufferOES) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Target)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUnmapBufferOES(d binary.Decoder, o *GlUnmapBufferOES) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Target = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = GLboolean(obj)
	}
	return nil
}
func doSkipGlUnmapBufferOES(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUnmapBufferOES) ID() binary.ID      { return binaryIDGlUnmapBufferOES }
func (*binaryClassGlUnmapBufferOES) New() binary.Object { return &GlUnmapBufferOES{} }
func (*binaryClassGlUnmapBufferOES) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUnmapBufferOES(e, obj.(*GlUnmapBufferOES))
}
func (*binaryClassGlUnmapBufferOES) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUnmapBufferOES{}
	return obj, doDecodeGlUnmapBufferOES(d, obj)
}
func (*binaryClassGlUnmapBufferOES) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUnmapBufferOES(d, obj.(*GlUnmapBufferOES))
}
func (*binaryClassGlUnmapBufferOES) Skip(d binary.Decoder) error { return doSkipGlUnmapBufferOES(d) }
func (*binaryClassGlUnmapBufferOES) Schema() *schema.Class       { return schemaGlUnmapBufferOES }

var schemaGlUnmapBufferOES = &schema.Class{
	TypeID:  binaryIDGlUnmapBufferOES,
	Package: "gles",
	Name:    "GlUnmapBufferOES",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
	},
}

type binaryClassGlUseProgram struct{}

func (*GlUseProgram) Class() binary.Class {
	return (*binaryClassGlUseProgram)(nil)
}
func doEncodeGlUseProgram(e binary.Encoder, o *GlUseProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUseProgram(d binary.Decoder, o *GlUseProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlUseProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUseProgram) ID() binary.ID      { return binaryIDGlUseProgram }
func (*binaryClassGlUseProgram) New() binary.Object { return &GlUseProgram{} }
func (*binaryClassGlUseProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUseProgram(e, obj.(*GlUseProgram))
}
func (*binaryClassGlUseProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUseProgram{}
	return obj, doDecodeGlUseProgram(d, obj)
}
func (*binaryClassGlUseProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUseProgram(d, obj.(*GlUseProgram))
}
func (*binaryClassGlUseProgram) Skip(d binary.Decoder) error { return doSkipGlUseProgram(d) }
func (*binaryClassGlUseProgram) Schema() *schema.Class       { return schemaGlUseProgram }

var schemaGlUseProgram = &schema.Class{
	TypeID:  binaryIDGlUseProgram,
	Package: "gles",
	Name:    "GlUseProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlUseProgramStages struct{}

func (*GlUseProgramStages) Class() binary.Class {
	return (*binaryClassGlUseProgramStages)(nil)
}
func doEncodeGlUseProgramStages(e binary.Encoder, o *GlUseProgramStages) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Stages)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUseProgramStages(d binary.Decoder, o *GlUseProgramStages) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Stages = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlUseProgramStages(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUseProgramStages) ID() binary.ID      { return binaryIDGlUseProgramStages }
func (*binaryClassGlUseProgramStages) New() binary.Object { return &GlUseProgramStages{} }
func (*binaryClassGlUseProgramStages) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUseProgramStages(e, obj.(*GlUseProgramStages))
}
func (*binaryClassGlUseProgramStages) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUseProgramStages{}
	return obj, doDecodeGlUseProgramStages(d, obj)
}
func (*binaryClassGlUseProgramStages) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUseProgramStages(d, obj.(*GlUseProgramStages))
}
func (*binaryClassGlUseProgramStages) Skip(d binary.Decoder) error { return doSkipGlUseProgramStages(d) }
func (*binaryClassGlUseProgramStages) Schema() *schema.Class       { return schemaGlUseProgramStages }

var schemaGlUseProgramStages = &schema.Class{
	TypeID:  binaryIDGlUseProgramStages,
	Package: "gles",
	Name:    "GlUseProgramStages",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Stages", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlUseProgramStagesEXT struct{}

func (*GlUseProgramStagesEXT) Class() binary.Class {
	return (*binaryClassGlUseProgramStagesEXT)(nil)
}
func doEncodeGlUseProgramStagesEXT(e binary.Encoder, o *GlUseProgramStagesEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Stages)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlUseProgramStagesEXT(d binary.Decoder, o *GlUseProgramStagesEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Stages = GLbitfield(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlUseProgramStagesEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlUseProgramStagesEXT) ID() binary.ID      { return binaryIDGlUseProgramStagesEXT }
func (*binaryClassGlUseProgramStagesEXT) New() binary.Object { return &GlUseProgramStagesEXT{} }
func (*binaryClassGlUseProgramStagesEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlUseProgramStagesEXT(e, obj.(*GlUseProgramStagesEXT))
}
func (*binaryClassGlUseProgramStagesEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlUseProgramStagesEXT{}
	return obj, doDecodeGlUseProgramStagesEXT(d, obj)
}
func (*binaryClassGlUseProgramStagesEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlUseProgramStagesEXT(d, obj.(*GlUseProgramStagesEXT))
}
func (*binaryClassGlUseProgramStagesEXT) Skip(d binary.Decoder) error {
	return doSkipGlUseProgramStagesEXT(d)
}
func (*binaryClassGlUseProgramStagesEXT) Schema() *schema.Class { return schemaGlUseProgramStagesEXT }

var schemaGlUseProgramStagesEXT = &schema.Class{
	TypeID:  binaryIDGlUseProgramStagesEXT,
	Package: "gles",
	Name:    "GlUseProgramStagesEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
		{Declared: "Stages", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlValidateProgram struct{}

func (*GlValidateProgram) Class() binary.Class {
	return (*binaryClassGlValidateProgram)(nil)
}
func doEncodeGlValidateProgram(e binary.Encoder, o *GlValidateProgram) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Program)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlValidateProgram(d binary.Decoder, o *GlValidateProgram) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Program = ProgramId(obj)
	}
	return nil
}
func doSkipGlValidateProgram(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlValidateProgram) ID() binary.ID      { return binaryIDGlValidateProgram }
func (*binaryClassGlValidateProgram) New() binary.Object { return &GlValidateProgram{} }
func (*binaryClassGlValidateProgram) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlValidateProgram(e, obj.(*GlValidateProgram))
}
func (*binaryClassGlValidateProgram) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlValidateProgram{}
	return obj, doDecodeGlValidateProgram(d, obj)
}
func (*binaryClassGlValidateProgram) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlValidateProgram(d, obj.(*GlValidateProgram))
}
func (*binaryClassGlValidateProgram) Skip(d binary.Decoder) error { return doSkipGlValidateProgram(d) }
func (*binaryClassGlValidateProgram) Schema() *schema.Class       { return schemaGlValidateProgram }

var schemaGlValidateProgram = &schema.Class{
	TypeID:  binaryIDGlValidateProgram,
	Package: "gles",
	Name:    "GlValidateProgram",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}},
	},
}

type binaryClassGlValidateProgramPipeline struct{}

func (*GlValidateProgramPipeline) Class() binary.Class {
	return (*binaryClassGlValidateProgramPipeline)(nil)
}
func doEncodeGlValidateProgramPipeline(e binary.Encoder, o *GlValidateProgramPipeline) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlValidateProgramPipeline(d binary.Decoder, o *GlValidateProgramPipeline) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	return nil
}
func doSkipGlValidateProgramPipeline(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlValidateProgramPipeline) ID() binary.ID      { return binaryIDGlValidateProgramPipeline }
func (*binaryClassGlValidateProgramPipeline) New() binary.Object { return &GlValidateProgramPipeline{} }
func (*binaryClassGlValidateProgramPipeline) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlValidateProgramPipeline(e, obj.(*GlValidateProgramPipeline))
}
func (*binaryClassGlValidateProgramPipeline) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlValidateProgramPipeline{}
	return obj, doDecodeGlValidateProgramPipeline(d, obj)
}
func (*binaryClassGlValidateProgramPipeline) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlValidateProgramPipeline(d, obj.(*GlValidateProgramPipeline))
}
func (*binaryClassGlValidateProgramPipeline) Skip(d binary.Decoder) error {
	return doSkipGlValidateProgramPipeline(d)
}
func (*binaryClassGlValidateProgramPipeline) Schema() *schema.Class {
	return schemaGlValidateProgramPipeline
}

var schemaGlValidateProgramPipeline = &schema.Class{
	TypeID:  binaryIDGlValidateProgramPipeline,
	Package: "gles",
	Name:    "GlValidateProgramPipeline",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
	},
}

type binaryClassGlValidateProgramPipelineEXT struct{}

func (*GlValidateProgramPipelineEXT) Class() binary.Class {
	return (*binaryClassGlValidateProgramPipelineEXT)(nil)
}
func doEncodeGlValidateProgramPipelineEXT(e binary.Encoder, o *GlValidateProgramPipelineEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Pipeline)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlValidateProgramPipelineEXT(d binary.Decoder, o *GlValidateProgramPipelineEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Pipeline = PipelineId(obj)
	}
	return nil
}
func doSkipGlValidateProgramPipelineEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlValidateProgramPipelineEXT) ID() binary.ID {
	return binaryIDGlValidateProgramPipelineEXT
}
func (*binaryClassGlValidateProgramPipelineEXT) New() binary.Object {
	return &GlValidateProgramPipelineEXT{}
}
func (*binaryClassGlValidateProgramPipelineEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlValidateProgramPipelineEXT(e, obj.(*GlValidateProgramPipelineEXT))
}
func (*binaryClassGlValidateProgramPipelineEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlValidateProgramPipelineEXT{}
	return obj, doDecodeGlValidateProgramPipelineEXT(d, obj)
}
func (*binaryClassGlValidateProgramPipelineEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlValidateProgramPipelineEXT(d, obj.(*GlValidateProgramPipelineEXT))
}
func (*binaryClassGlValidateProgramPipelineEXT) Skip(d binary.Decoder) error {
	return doSkipGlValidateProgramPipelineEXT(d)
}
func (*binaryClassGlValidateProgramPipelineEXT) Schema() *schema.Class {
	return schemaGlValidateProgramPipelineEXT
}

var schemaGlValidateProgramPipelineEXT = &schema.Class{
	TypeID:  binaryIDGlValidateProgramPipelineEXT,
	Package: "gles",
	Name:    "GlValidateProgramPipelineEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttrib1f struct{}

func (*GlVertexAttrib1f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib1f)(nil)
}
func doEncodeGlVertexAttrib1f(e binary.Encoder, o *GlVertexAttrib1f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib1f(d binary.Decoder, o *GlVertexAttrib1f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	return nil
}
func doSkipGlVertexAttrib1f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib1f) ID() binary.ID      { return binaryIDGlVertexAttrib1f }
func (*binaryClassGlVertexAttrib1f) New() binary.Object { return &GlVertexAttrib1f{} }
func (*binaryClassGlVertexAttrib1f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib1f(e, obj.(*GlVertexAttrib1f))
}
func (*binaryClassGlVertexAttrib1f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib1f{}
	return obj, doDecodeGlVertexAttrib1f(d, obj)
}
func (*binaryClassGlVertexAttrib1f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib1f(d, obj.(*GlVertexAttrib1f))
}
func (*binaryClassGlVertexAttrib1f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib1f(d) }
func (*binaryClassGlVertexAttrib1f) Schema() *schema.Class       { return schemaGlVertexAttrib1f }

var schemaGlVertexAttrib1f = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib1f,
	Package: "gles",
	Name:    "GlVertexAttrib1f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlVertexAttrib1fv struct{}

func (*GlVertexAttrib1fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib1fv)(nil)
}
func doEncodeGlVertexAttrib1fv(e binary.Encoder, o *GlVertexAttrib1fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib1fv(d binary.Decoder, o *GlVertexAttrib1fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttrib1fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib1fv) ID() binary.ID      { return binaryIDGlVertexAttrib1fv }
func (*binaryClassGlVertexAttrib1fv) New() binary.Object { return &GlVertexAttrib1fv{} }
func (*binaryClassGlVertexAttrib1fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib1fv(e, obj.(*GlVertexAttrib1fv))
}
func (*binaryClassGlVertexAttrib1fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib1fv{}
	return obj, doDecodeGlVertexAttrib1fv(d, obj)
}
func (*binaryClassGlVertexAttrib1fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib1fv(d, obj.(*GlVertexAttrib1fv))
}
func (*binaryClassGlVertexAttrib1fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib1fv(d) }
func (*binaryClassGlVertexAttrib1fv) Schema() *schema.Class       { return schemaGlVertexAttrib1fv }

var schemaGlVertexAttrib1fv = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib1fv,
	Package: "gles",
	Name:    "GlVertexAttrib1fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttrib2f struct{}

func (*GlVertexAttrib2f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib2f)(nil)
}
func doEncodeGlVertexAttrib2f(e binary.Encoder, o *GlVertexAttrib2f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib2f(d binary.Decoder, o *GlVertexAttrib2f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	return nil
}
func doSkipGlVertexAttrib2f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib2f) ID() binary.ID      { return binaryIDGlVertexAttrib2f }
func (*binaryClassGlVertexAttrib2f) New() binary.Object { return &GlVertexAttrib2f{} }
func (*binaryClassGlVertexAttrib2f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib2f(e, obj.(*GlVertexAttrib2f))
}
func (*binaryClassGlVertexAttrib2f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib2f{}
	return obj, doDecodeGlVertexAttrib2f(d, obj)
}
func (*binaryClassGlVertexAttrib2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib2f(d, obj.(*GlVertexAttrib2f))
}
func (*binaryClassGlVertexAttrib2f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib2f(d) }
func (*binaryClassGlVertexAttrib2f) Schema() *schema.Class       { return schemaGlVertexAttrib2f }

var schemaGlVertexAttrib2f = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib2f,
	Package: "gles",
	Name:    "GlVertexAttrib2f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlVertexAttrib2fv struct{}

func (*GlVertexAttrib2fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib2fv)(nil)
}
func doEncodeGlVertexAttrib2fv(e binary.Encoder, o *GlVertexAttrib2fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib2fv(d binary.Decoder, o *GlVertexAttrib2fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttrib2fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib2fv) ID() binary.ID      { return binaryIDGlVertexAttrib2fv }
func (*binaryClassGlVertexAttrib2fv) New() binary.Object { return &GlVertexAttrib2fv{} }
func (*binaryClassGlVertexAttrib2fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib2fv(e, obj.(*GlVertexAttrib2fv))
}
func (*binaryClassGlVertexAttrib2fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib2fv{}
	return obj, doDecodeGlVertexAttrib2fv(d, obj)
}
func (*binaryClassGlVertexAttrib2fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib2fv(d, obj.(*GlVertexAttrib2fv))
}
func (*binaryClassGlVertexAttrib2fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib2fv(d) }
func (*binaryClassGlVertexAttrib2fv) Schema() *schema.Class       { return schemaGlVertexAttrib2fv }

var schemaGlVertexAttrib2fv = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib2fv,
	Package: "gles",
	Name:    "GlVertexAttrib2fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttrib3f struct{}

func (*GlVertexAttrib3f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib3f)(nil)
}
func doEncodeGlVertexAttrib3f(e binary.Encoder, o *GlVertexAttrib3f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value2)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib3f(d binary.Decoder, o *GlVertexAttrib3f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value2 = GLfloat(obj)
	}
	return nil
}
func doSkipGlVertexAttrib3f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib3f) ID() binary.ID      { return binaryIDGlVertexAttrib3f }
func (*binaryClassGlVertexAttrib3f) New() binary.Object { return &GlVertexAttrib3f{} }
func (*binaryClassGlVertexAttrib3f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib3f(e, obj.(*GlVertexAttrib3f))
}
func (*binaryClassGlVertexAttrib3f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib3f{}
	return obj, doDecodeGlVertexAttrib3f(d, obj)
}
func (*binaryClassGlVertexAttrib3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib3f(d, obj.(*GlVertexAttrib3f))
}
func (*binaryClassGlVertexAttrib3f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib3f(d) }
func (*binaryClassGlVertexAttrib3f) Schema() *schema.Class       { return schemaGlVertexAttrib3f }

var schemaGlVertexAttrib3f = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib3f,
	Package: "gles",
	Name:    "GlVertexAttrib3f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlVertexAttrib3fv struct{}

func (*GlVertexAttrib3fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib3fv)(nil)
}
func doEncodeGlVertexAttrib3fv(e binary.Encoder, o *GlVertexAttrib3fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib3fv(d binary.Decoder, o *GlVertexAttrib3fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttrib3fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib3fv) ID() binary.ID      { return binaryIDGlVertexAttrib3fv }
func (*binaryClassGlVertexAttrib3fv) New() binary.Object { return &GlVertexAttrib3fv{} }
func (*binaryClassGlVertexAttrib3fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib3fv(e, obj.(*GlVertexAttrib3fv))
}
func (*binaryClassGlVertexAttrib3fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib3fv{}
	return obj, doDecodeGlVertexAttrib3fv(d, obj)
}
func (*binaryClassGlVertexAttrib3fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib3fv(d, obj.(*GlVertexAttrib3fv))
}
func (*binaryClassGlVertexAttrib3fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib3fv(d) }
func (*binaryClassGlVertexAttrib3fv) Schema() *schema.Class       { return schemaGlVertexAttrib3fv }

var schemaGlVertexAttrib3fv = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib3fv,
	Package: "gles",
	Name:    "GlVertexAttrib3fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttrib4f struct{}

func (*GlVertexAttrib4f) Class() binary.Class {
	return (*binaryClassGlVertexAttrib4f)(nil)
}
func doEncodeGlVertexAttrib4f(e binary.Encoder, o *GlVertexAttrib4f) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value0)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value1)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value2)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Value3)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib4f(d binary.Decoder, o *GlVertexAttrib4f) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value0 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value1 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value2 = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Value3 = GLfloat(obj)
	}
	return nil
}
func doSkipGlVertexAttrib4f(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib4f) ID() binary.ID      { return binaryIDGlVertexAttrib4f }
func (*binaryClassGlVertexAttrib4f) New() binary.Object { return &GlVertexAttrib4f{} }
func (*binaryClassGlVertexAttrib4f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib4f(e, obj.(*GlVertexAttrib4f))
}
func (*binaryClassGlVertexAttrib4f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib4f{}
	return obj, doDecodeGlVertexAttrib4f(d, obj)
}
func (*binaryClassGlVertexAttrib4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib4f(d, obj.(*GlVertexAttrib4f))
}
func (*binaryClassGlVertexAttrib4f) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib4f(d) }
func (*binaryClassGlVertexAttrib4f) Schema() *schema.Class       { return schemaGlVertexAttrib4f }

var schemaGlVertexAttrib4f = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib4f,
	Package: "gles",
	Name:    "GlVertexAttrib4f",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value0", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value1", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value2", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Value3", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlVertexAttrib4fv struct{}

func (*GlVertexAttrib4fv) Class() binary.Class {
	return (*binaryClassGlVertexAttrib4fv)(nil)
}
func doEncodeGlVertexAttrib4fv(e binary.Encoder, o *GlVertexAttrib4fv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttrib4fv(d binary.Decoder, o *GlVertexAttrib4fv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttrib4fv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttrib4fv) ID() binary.ID      { return binaryIDGlVertexAttrib4fv }
func (*binaryClassGlVertexAttrib4fv) New() binary.Object { return &GlVertexAttrib4fv{} }
func (*binaryClassGlVertexAttrib4fv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttrib4fv(e, obj.(*GlVertexAttrib4fv))
}
func (*binaryClassGlVertexAttrib4fv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttrib4fv{}
	return obj, doDecodeGlVertexAttrib4fv(d, obj)
}
func (*binaryClassGlVertexAttrib4fv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttrib4fv(d, obj.(*GlVertexAttrib4fv))
}
func (*binaryClassGlVertexAttrib4fv) Skip(d binary.Decoder) error { return doSkipGlVertexAttrib4fv(d) }
func (*binaryClassGlVertexAttrib4fv) Schema() *schema.Class       { return schemaGlVertexAttrib4fv }

var schemaGlVertexAttrib4fv = &schema.Class{
	TypeID:  binaryIDGlVertexAttrib4fv,
	Package: "gles",
	Name:    "GlVertexAttrib4fv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Value", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttribBinding struct{}

func (*GlVertexAttribBinding) Class() binary.Class {
	return (*binaryClassGlVertexAttribBinding)(nil)
}
func doEncodeGlVertexAttribBinding(e binary.Encoder, o *GlVertexAttribBinding) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attribindex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Bindingindex)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribBinding(d binary.Decoder, o *GlVertexAttribBinding) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attribindex = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Bindingindex = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribBinding(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribBinding) ID() binary.ID      { return binaryIDGlVertexAttribBinding }
func (*binaryClassGlVertexAttribBinding) New() binary.Object { return &GlVertexAttribBinding{} }
func (*binaryClassGlVertexAttribBinding) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribBinding(e, obj.(*GlVertexAttribBinding))
}
func (*binaryClassGlVertexAttribBinding) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribBinding{}
	return obj, doDecodeGlVertexAttribBinding(d, obj)
}
func (*binaryClassGlVertexAttribBinding) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribBinding(d, obj.(*GlVertexAttribBinding))
}
func (*binaryClassGlVertexAttribBinding) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribBinding(d)
}
func (*binaryClassGlVertexAttribBinding) Schema() *schema.Class { return schemaGlVertexAttribBinding }

var schemaGlVertexAttribBinding = &schema.Class{
	TypeID:  binaryIDGlVertexAttribBinding,
	Package: "gles",
	Name:    "GlVertexAttribBinding",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Attribindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Bindingindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribDivisor struct{}

func (*GlVertexAttribDivisor) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisor)(nil)
}
func doEncodeGlVertexAttribDivisor(e binary.Encoder, o *GlVertexAttribDivisor) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Divisor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribDivisor(d binary.Decoder, o *GlVertexAttribDivisor) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Divisor = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribDivisor(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribDivisor) ID() binary.ID      { return binaryIDGlVertexAttribDivisor }
func (*binaryClassGlVertexAttribDivisor) New() binary.Object { return &GlVertexAttribDivisor{} }
func (*binaryClassGlVertexAttribDivisor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribDivisor(e, obj.(*GlVertexAttribDivisor))
}
func (*binaryClassGlVertexAttribDivisor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribDivisor{}
	return obj, doDecodeGlVertexAttribDivisor(d, obj)
}
func (*binaryClassGlVertexAttribDivisor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribDivisor(d, obj.(*GlVertexAttribDivisor))
}
func (*binaryClassGlVertexAttribDivisor) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribDivisor(d)
}
func (*binaryClassGlVertexAttribDivisor) Schema() *schema.Class { return schemaGlVertexAttribDivisor }

var schemaGlVertexAttribDivisor = &schema.Class{
	TypeID:  binaryIDGlVertexAttribDivisor,
	Package: "gles",
	Name:    "GlVertexAttribDivisor",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Divisor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribDivisorANGLE struct{}

func (*GlVertexAttribDivisorANGLE) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorANGLE)(nil)
}
func doEncodeGlVertexAttribDivisorANGLE(e binary.Encoder, o *GlVertexAttribDivisorANGLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Divisor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribDivisorANGLE(d binary.Decoder, o *GlVertexAttribDivisorANGLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Divisor = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribDivisorANGLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribDivisorANGLE) ID() binary.ID {
	return binaryIDGlVertexAttribDivisorANGLE
}
func (*binaryClassGlVertexAttribDivisorANGLE) New() binary.Object {
	return &GlVertexAttribDivisorANGLE{}
}
func (*binaryClassGlVertexAttribDivisorANGLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribDivisorANGLE(e, obj.(*GlVertexAttribDivisorANGLE))
}
func (*binaryClassGlVertexAttribDivisorANGLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribDivisorANGLE{}
	return obj, doDecodeGlVertexAttribDivisorANGLE(d, obj)
}
func (*binaryClassGlVertexAttribDivisorANGLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribDivisorANGLE(d, obj.(*GlVertexAttribDivisorANGLE))
}
func (*binaryClassGlVertexAttribDivisorANGLE) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribDivisorANGLE(d)
}
func (*binaryClassGlVertexAttribDivisorANGLE) Schema() *schema.Class {
	return schemaGlVertexAttribDivisorANGLE
}

var schemaGlVertexAttribDivisorANGLE = &schema.Class{
	TypeID:  binaryIDGlVertexAttribDivisorANGLE,
	Package: "gles",
	Name:    "GlVertexAttribDivisorANGLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Divisor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribDivisorEXT struct{}

func (*GlVertexAttribDivisorEXT) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorEXT)(nil)
}
func doEncodeGlVertexAttribDivisorEXT(e binary.Encoder, o *GlVertexAttribDivisorEXT) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Divisor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribDivisorEXT(d binary.Decoder, o *GlVertexAttribDivisorEXT) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Divisor = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribDivisorEXT(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribDivisorEXT) ID() binary.ID      { return binaryIDGlVertexAttribDivisorEXT }
func (*binaryClassGlVertexAttribDivisorEXT) New() binary.Object { return &GlVertexAttribDivisorEXT{} }
func (*binaryClassGlVertexAttribDivisorEXT) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribDivisorEXT(e, obj.(*GlVertexAttribDivisorEXT))
}
func (*binaryClassGlVertexAttribDivisorEXT) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribDivisorEXT{}
	return obj, doDecodeGlVertexAttribDivisorEXT(d, obj)
}
func (*binaryClassGlVertexAttribDivisorEXT) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribDivisorEXT(d, obj.(*GlVertexAttribDivisorEXT))
}
func (*binaryClassGlVertexAttribDivisorEXT) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribDivisorEXT(d)
}
func (*binaryClassGlVertexAttribDivisorEXT) Schema() *schema.Class {
	return schemaGlVertexAttribDivisorEXT
}

var schemaGlVertexAttribDivisorEXT = &schema.Class{
	TypeID:  binaryIDGlVertexAttribDivisorEXT,
	Package: "gles",
	Name:    "GlVertexAttribDivisorEXT",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Divisor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribDivisorNV struct{}

func (*GlVertexAttribDivisorNV) Class() binary.Class {
	return (*binaryClassGlVertexAttribDivisorNV)(nil)
}
func doEncodeGlVertexAttribDivisorNV(e binary.Encoder, o *GlVertexAttribDivisorNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Divisor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribDivisorNV(d binary.Decoder, o *GlVertexAttribDivisorNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Divisor = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribDivisorNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribDivisorNV) ID() binary.ID      { return binaryIDGlVertexAttribDivisorNV }
func (*binaryClassGlVertexAttribDivisorNV) New() binary.Object { return &GlVertexAttribDivisorNV{} }
func (*binaryClassGlVertexAttribDivisorNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribDivisorNV(e, obj.(*GlVertexAttribDivisorNV))
}
func (*binaryClassGlVertexAttribDivisorNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribDivisorNV{}
	return obj, doDecodeGlVertexAttribDivisorNV(d, obj)
}
func (*binaryClassGlVertexAttribDivisorNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribDivisorNV(d, obj.(*GlVertexAttribDivisorNV))
}
func (*binaryClassGlVertexAttribDivisorNV) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribDivisorNV(d)
}
func (*binaryClassGlVertexAttribDivisorNV) Schema() *schema.Class {
	return schemaGlVertexAttribDivisorNV
}

var schemaGlVertexAttribDivisorNV = &schema.Class{
	TypeID:  binaryIDGlVertexAttribDivisorNV,
	Package: "gles",
	Name:    "GlVertexAttribDivisorNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Divisor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribFormat struct{}

func (*GlVertexAttribFormat) Class() binary.Class {
	return (*binaryClassGlVertexAttribFormat)(nil)
}
func doEncodeGlVertexAttribFormat(e binary.Encoder, o *GlVertexAttribFormat) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attribindex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Normalized)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Relativeoffset)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribFormat(d binary.Decoder, o *GlVertexAttribFormat) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attribindex = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Normalized = GLboolean(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Relativeoffset = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribFormat(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribFormat) ID() binary.ID      { return binaryIDGlVertexAttribFormat }
func (*binaryClassGlVertexAttribFormat) New() binary.Object { return &GlVertexAttribFormat{} }
func (*binaryClassGlVertexAttribFormat) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribFormat(e, obj.(*GlVertexAttribFormat))
}
func (*binaryClassGlVertexAttribFormat) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribFormat{}
	return obj, doDecodeGlVertexAttribFormat(d, obj)
}
func (*binaryClassGlVertexAttribFormat) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribFormat(d, obj.(*GlVertexAttribFormat))
}
func (*binaryClassGlVertexAttribFormat) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribFormat(d)
}
func (*binaryClassGlVertexAttribFormat) Schema() *schema.Class { return schemaGlVertexAttribFormat }

var schemaGlVertexAttribFormat = &schema.Class{
	TypeID:  binaryIDGlVertexAttribFormat,
	Package: "gles",
	Name:    "GlVertexAttribFormat",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Attribindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Normalized", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Relativeoffset", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribI4i struct{}

func (*GlVertexAttribI4i) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4i)(nil)
}
func doEncodeGlVertexAttribI4i(e binary.Encoder, o *GlVertexAttribI4i) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Z)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.W)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribI4i(d binary.Decoder, o *GlVertexAttribI4i) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Z = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.W = GLint(obj)
	}
	return nil
}
func doSkipGlVertexAttribI4i(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribI4i) ID() binary.ID      { return binaryIDGlVertexAttribI4i }
func (*binaryClassGlVertexAttribI4i) New() binary.Object { return &GlVertexAttribI4i{} }
func (*binaryClassGlVertexAttribI4i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribI4i(e, obj.(*GlVertexAttribI4i))
}
func (*binaryClassGlVertexAttribI4i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribI4i{}
	return obj, doDecodeGlVertexAttribI4i(d, obj)
}
func (*binaryClassGlVertexAttribI4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribI4i(d, obj.(*GlVertexAttribI4i))
}
func (*binaryClassGlVertexAttribI4i) Skip(d binary.Decoder) error { return doSkipGlVertexAttribI4i(d) }
func (*binaryClassGlVertexAttribI4i) Schema() *schema.Class       { return schemaGlVertexAttribI4i }

var schemaGlVertexAttribI4i = &schema.Class{
	TypeID:  binaryIDGlVertexAttribI4i,
	Package: "gles",
	Name:    "GlVertexAttribI4i",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Z", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "W", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
	},
}

type binaryClassGlVertexAttribI4iv struct{}

func (*GlVertexAttribI4iv) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4iv)(nil)
}
func doEncodeGlVertexAttribI4iv(e binary.Encoder, o *GlVertexAttribI4iv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribI4iv(d binary.Decoder, o *GlVertexAttribI4iv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttribI4iv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribI4iv) ID() binary.ID      { return binaryIDGlVertexAttribI4iv }
func (*binaryClassGlVertexAttribI4iv) New() binary.Object { return &GlVertexAttribI4iv{} }
func (*binaryClassGlVertexAttribI4iv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribI4iv(e, obj.(*GlVertexAttribI4iv))
}
func (*binaryClassGlVertexAttribI4iv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribI4iv{}
	return obj, doDecodeGlVertexAttribI4iv(d, obj)
}
func (*binaryClassGlVertexAttribI4iv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribI4iv(d, obj.(*GlVertexAttribI4iv))
}
func (*binaryClassGlVertexAttribI4iv) Skip(d binary.Decoder) error { return doSkipGlVertexAttribI4iv(d) }
func (*binaryClassGlVertexAttribI4iv) Schema() *schema.Class       { return schemaGlVertexAttribI4iv }

var schemaGlVertexAttribI4iv = &schema.Class{
	TypeID:  binaryIDGlVertexAttribI4iv,
	Package: "gles",
	Name:    "GlVertexAttribI4iv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLintᶜᵖ", ID: (*GLintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttribI4ui struct{}

func (*GlVertexAttribI4ui) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4ui)(nil)
}
func doEncodeGlVertexAttribI4ui(e binary.Encoder, o *GlVertexAttribI4ui) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.X)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Y)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Z)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.W)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribI4ui(d binary.Decoder, o *GlVertexAttribI4ui) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.X = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Y = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Z = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.W = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribI4ui(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribI4ui) ID() binary.ID      { return binaryIDGlVertexAttribI4ui }
func (*binaryClassGlVertexAttribI4ui) New() binary.Object { return &GlVertexAttribI4ui{} }
func (*binaryClassGlVertexAttribI4ui) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribI4ui(e, obj.(*GlVertexAttribI4ui))
}
func (*binaryClassGlVertexAttribI4ui) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribI4ui{}
	return obj, doDecodeGlVertexAttribI4ui(d, obj)
}
func (*binaryClassGlVertexAttribI4ui) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribI4ui(d, obj.(*GlVertexAttribI4ui))
}
func (*binaryClassGlVertexAttribI4ui) Skip(d binary.Decoder) error { return doSkipGlVertexAttribI4ui(d) }
func (*binaryClassGlVertexAttribI4ui) Schema() *schema.Class       { return schemaGlVertexAttribI4ui }

var schemaGlVertexAttribI4ui = &schema.Class{
	TypeID:  binaryIDGlVertexAttribI4ui,
	Package: "gles",
	Name:    "GlVertexAttribI4ui",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Z", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "W", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribI4uiv struct{}

func (*GlVertexAttribI4uiv) Class() binary.Class {
	return (*binaryClassGlVertexAttribI4uiv)(nil)
}
func doEncodeGlVertexAttribI4uiv(e binary.Encoder, o *GlVertexAttribI4uiv) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribI4uiv(d binary.Decoder, o *GlVertexAttribI4uiv) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttribI4uiv(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribI4uiv) ID() binary.ID      { return binaryIDGlVertexAttribI4uiv }
func (*binaryClassGlVertexAttribI4uiv) New() binary.Object { return &GlVertexAttribI4uiv{} }
func (*binaryClassGlVertexAttribI4uiv) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribI4uiv(e, obj.(*GlVertexAttribI4uiv))
}
func (*binaryClassGlVertexAttribI4uiv) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribI4uiv{}
	return obj, doDecodeGlVertexAttribI4uiv(d, obj)
}
func (*binaryClassGlVertexAttribI4uiv) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribI4uiv(d, obj.(*GlVertexAttribI4uiv))
}
func (*binaryClassGlVertexAttribI4uiv) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribI4uiv(d)
}
func (*binaryClassGlVertexAttribI4uiv) Schema() *schema.Class { return schemaGlVertexAttribI4uiv }

var schemaGlVertexAttribI4uiv = &schema.Class{
	TypeID:  binaryIDGlVertexAttribI4uiv,
	Package: "gles",
	Name:    "GlVertexAttribI4uiv",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttribIFormat struct{}

func (*GlVertexAttribIFormat) Class() binary.Class {
	return (*binaryClassGlVertexAttribIFormat)(nil)
}
func doEncodeGlVertexAttribIFormat(e binary.Encoder, o *GlVertexAttribIFormat) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Attribindex)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Relativeoffset)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribIFormat(d binary.Decoder, o *GlVertexAttribIFormat) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Attribindex = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Relativeoffset = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexAttribIFormat(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribIFormat) ID() binary.ID      { return binaryIDGlVertexAttribIFormat }
func (*binaryClassGlVertexAttribIFormat) New() binary.Object { return &GlVertexAttribIFormat{} }
func (*binaryClassGlVertexAttribIFormat) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribIFormat(e, obj.(*GlVertexAttribIFormat))
}
func (*binaryClassGlVertexAttribIFormat) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribIFormat{}
	return obj, doDecodeGlVertexAttribIFormat(d, obj)
}
func (*binaryClassGlVertexAttribIFormat) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribIFormat(d, obj.(*GlVertexAttribIFormat))
}
func (*binaryClassGlVertexAttribIFormat) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribIFormat(d)
}
func (*binaryClassGlVertexAttribIFormat) Schema() *schema.Class { return schemaGlVertexAttribIFormat }

var schemaGlVertexAttribIFormat = &schema.Class{
	TypeID:  binaryIDGlVertexAttribIFormat,
	Package: "gles",
	Name:    "GlVertexAttribIFormat",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Attribindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Relativeoffset", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlVertexAttribIPointer struct{}

func (*GlVertexAttribIPointer) Class() binary.Class {
	return (*binaryClassGlVertexAttribIPointer)(nil)
}
func doEncodeGlVertexAttribIPointer(e binary.Encoder, o *GlVertexAttribIPointer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribIPointer(d binary.Decoder, o *GlVertexAttribIPointer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = AttributeLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttribIPointer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribIPointer) ID() binary.ID      { return binaryIDGlVertexAttribIPointer }
func (*binaryClassGlVertexAttribIPointer) New() binary.Object { return &GlVertexAttribIPointer{} }
func (*binaryClassGlVertexAttribIPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribIPointer(e, obj.(*GlVertexAttribIPointer))
}
func (*binaryClassGlVertexAttribIPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribIPointer{}
	return obj, doDecodeGlVertexAttribIPointer(d, obj)
}
func (*binaryClassGlVertexAttribIPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribIPointer(d, obj.(*GlVertexAttribIPointer))
}
func (*binaryClassGlVertexAttribIPointer) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribIPointer(d)
}
func (*binaryClassGlVertexAttribIPointer) Schema() *schema.Class { return schemaGlVertexAttribIPointer }

var schemaGlVertexAttribIPointer = &schema.Class{
	TypeID:  binaryIDGlVertexAttribIPointer,
	Package: "gles",
	Name:    "GlVertexAttribIPointer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Pointer", Type: &schema.Struct{Name: "Voidᶜᵖ", ID: (*Voidᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexAttribPointer struct{}

func (*GlVertexAttribPointer) Class() binary.Class {
	return (*binaryClassGlVertexAttribPointer)(nil)
}
func doEncodeGlVertexAttribPointer(e binary.Encoder, o *GlVertexAttribPointer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Location)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Size)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Type)); err != nil {
		return err
	}
	if err := e.Uint8(uint8(o.Normalized)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Stride)); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexAttribPointer(d binary.Decoder, o *GlVertexAttribPointer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Location = AttributeLocation(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Size = GLint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = GLenum(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Normalized = GLboolean(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Stride = GLsizei(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipGlVertexAttribPointer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*VertexPointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexAttribPointer) ID() binary.ID      { return binaryIDGlVertexAttribPointer }
func (*binaryClassGlVertexAttribPointer) New() binary.Object { return &GlVertexAttribPointer{} }
func (*binaryClassGlVertexAttribPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexAttribPointer(e, obj.(*GlVertexAttribPointer))
}
func (*binaryClassGlVertexAttribPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexAttribPointer{}
	return obj, doDecodeGlVertexAttribPointer(d, obj)
}
func (*binaryClassGlVertexAttribPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexAttribPointer(d, obj.(*GlVertexAttribPointer))
}
func (*binaryClassGlVertexAttribPointer) Skip(d binary.Decoder) error {
	return doSkipGlVertexAttribPointer(d)
}
func (*binaryClassGlVertexAttribPointer) Schema() *schema.Class { return schemaGlVertexAttribPointer }

var schemaGlVertexAttribPointer = &schema.Class{
	TypeID:  binaryIDGlVertexAttribPointer,
	Package: "gles",
	Name:    "GlVertexAttribPointer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}},
		{Declared: "Size", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}},
		{Declared: "Normalized", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}},
		{Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Data", Type: &schema.Struct{Name: "VertexPointer", ID: (*VertexPointer)(nil).Class().ID()}},
	},
}

type binaryClassGlVertexBindingDivisor struct{}

func (*GlVertexBindingDivisor) Class() binary.Class {
	return (*binaryClassGlVertexBindingDivisor)(nil)
}
func doEncodeGlVertexBindingDivisor(e binary.Encoder, o *GlVertexBindingDivisor) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Bindingindex)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Divisor)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlVertexBindingDivisor(d binary.Decoder, o *GlVertexBindingDivisor) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Bindingindex = GLuint(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Divisor = GLuint(obj)
	}
	return nil
}
func doSkipGlVertexBindingDivisor(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlVertexBindingDivisor) ID() binary.ID      { return binaryIDGlVertexBindingDivisor }
func (*binaryClassGlVertexBindingDivisor) New() binary.Object { return &GlVertexBindingDivisor{} }
func (*binaryClassGlVertexBindingDivisor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlVertexBindingDivisor(e, obj.(*GlVertexBindingDivisor))
}
func (*binaryClassGlVertexBindingDivisor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlVertexBindingDivisor{}
	return obj, doDecodeGlVertexBindingDivisor(d, obj)
}
func (*binaryClassGlVertexBindingDivisor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlVertexBindingDivisor(d, obj.(*GlVertexBindingDivisor))
}
func (*binaryClassGlVertexBindingDivisor) Skip(d binary.Decoder) error {
	return doSkipGlVertexBindingDivisor(d)
}
func (*binaryClassGlVertexBindingDivisor) Schema() *schema.Class { return schemaGlVertexBindingDivisor }

var schemaGlVertexBindingDivisor = &schema.Class{
	TypeID:  binaryIDGlVertexBindingDivisor,
	Package: "gles",
	Name:    "GlVertexBindingDivisor",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Bindingindex", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Divisor", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
	},
}

type binaryClassGlViewport struct{}

func (*GlViewport) Class() binary.Class {
	return (*binaryClassGlViewport)(nil)
}
func doEncodeGlViewport(e binary.Encoder, o *GlViewport) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(int32(o.X)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Y)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Width)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Height)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlViewport(d binary.Decoder, o *GlViewport) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.X = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Y = GLint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Width = GLsizei(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Height = GLsizei(obj)
	}
	return nil
}
func doSkipGlViewport(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlViewport) ID() binary.ID      { return binaryIDGlViewport }
func (*binaryClassGlViewport) New() binary.Object { return &GlViewport{} }
func (*binaryClassGlViewport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlViewport(e, obj.(*GlViewport))
}
func (*binaryClassGlViewport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlViewport{}
	return obj, doDecodeGlViewport(d, obj)
}
func (*binaryClassGlViewport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlViewport(d, obj.(*GlViewport))
}
func (*binaryClassGlViewport) Skip(d binary.Decoder) error { return doSkipGlViewport(d) }
func (*binaryClassGlViewport) Schema() *schema.Class       { return schemaGlViewport }

var schemaGlViewport = &schema.Class{
	TypeID:  binaryIDGlViewport,
	Package: "gles",
	Name:    "GlViewport",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}},
		{Declared: "Width", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Height", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
	},
}

type binaryClassGlViewportArrayvNV struct{}

func (*GlViewportArrayvNV) Class() binary.Class {
	return (*binaryClassGlViewportArrayvNV)(nil)
}
func doEncodeGlViewportArrayvNV(e binary.Encoder, o *GlViewportArrayvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.First)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Count)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlViewportArrayvNV(d binary.Decoder, o *GlViewportArrayvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.First = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = GLsizei(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlViewportArrayvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlViewportArrayvNV) ID() binary.ID      { return binaryIDGlViewportArrayvNV }
func (*binaryClassGlViewportArrayvNV) New() binary.Object { return &GlViewportArrayvNV{} }
func (*binaryClassGlViewportArrayvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlViewportArrayvNV(e, obj.(*GlViewportArrayvNV))
}
func (*binaryClassGlViewportArrayvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlViewportArrayvNV{}
	return obj, doDecodeGlViewportArrayvNV(d, obj)
}
func (*binaryClassGlViewportArrayvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlViewportArrayvNV(d, obj.(*GlViewportArrayvNV))
}
func (*binaryClassGlViewportArrayvNV) Skip(d binary.Decoder) error { return doSkipGlViewportArrayvNV(d) }
func (*binaryClassGlViewportArrayvNV) Schema() *schema.Class       { return schemaGlViewportArrayvNV }

var schemaGlViewportArrayvNV = &schema.Class{
	TypeID:  binaryIDGlViewportArrayvNV,
	Package: "gles",
	Name:    "GlViewportArrayvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "First", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "Count", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlViewportIndexedfNV struct{}

func (*GlViewportIndexedfNV) Class() binary.Class {
	return (*binaryClassGlViewportIndexedfNV)(nil)
}
func doEncodeGlViewportIndexedfNV(e binary.Encoder, o *GlViewportIndexedfNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.X)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.Y)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.W)); err != nil {
		return err
	}
	if err := e.Float32(float32(o.H)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlViewportIndexedfNV(d binary.Decoder, o *GlViewportIndexedfNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.X = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Y = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.W = GLfloat(obj)
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.H = GLfloat(obj)
	}
	return nil
}
func doSkipGlViewportIndexedfNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlViewportIndexedfNV) ID() binary.ID      { return binaryIDGlViewportIndexedfNV }
func (*binaryClassGlViewportIndexedfNV) New() binary.Object { return &GlViewportIndexedfNV{} }
func (*binaryClassGlViewportIndexedfNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlViewportIndexedfNV(e, obj.(*GlViewportIndexedfNV))
}
func (*binaryClassGlViewportIndexedfNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlViewportIndexedfNV{}
	return obj, doDecodeGlViewportIndexedfNV(d, obj)
}
func (*binaryClassGlViewportIndexedfNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlViewportIndexedfNV(d, obj.(*GlViewportIndexedfNV))
}
func (*binaryClassGlViewportIndexedfNV) Skip(d binary.Decoder) error {
	return doSkipGlViewportIndexedfNV(d)
}
func (*binaryClassGlViewportIndexedfNV) Schema() *schema.Class { return schemaGlViewportIndexedfNV }

var schemaGlViewportIndexedfNV = &schema.Class{
	TypeID:  binaryIDGlViewportIndexedfNV,
	Package: "gles",
	Name:    "GlViewportIndexedfNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "X", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "Y", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "W", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
		{Declared: "H", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}},
	},
}

type binaryClassGlViewportIndexedfvNV struct{}

func (*GlViewportIndexedfvNV) Class() binary.Class {
	return (*binaryClassGlViewportIndexedfvNV)(nil)
}
func doEncodeGlViewportIndexedfvNV(e binary.Encoder, o *GlViewportIndexedfvNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Index)); err != nil {
		return err
	}
	if err := e.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doDecodeGlViewportIndexedfvNV(d binary.Decoder, o *GlViewportIndexedfvNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Index = GLuint(obj)
	}
	if err := d.Value(&o.V); err != nil {
		return err
	}
	return nil
}
func doSkipGlViewportIndexedfvNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlViewportIndexedfvNV) ID() binary.ID      { return binaryIDGlViewportIndexedfvNV }
func (*binaryClassGlViewportIndexedfvNV) New() binary.Object { return &GlViewportIndexedfvNV{} }
func (*binaryClassGlViewportIndexedfvNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlViewportIndexedfvNV(e, obj.(*GlViewportIndexedfvNV))
}
func (*binaryClassGlViewportIndexedfvNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlViewportIndexedfvNV{}
	return obj, doDecodeGlViewportIndexedfvNV(d, obj)
}
func (*binaryClassGlViewportIndexedfvNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlViewportIndexedfvNV(d, obj.(*GlViewportIndexedfvNV))
}
func (*binaryClassGlViewportIndexedfvNV) Skip(d binary.Decoder) error {
	return doSkipGlViewportIndexedfvNV(d)
}
func (*binaryClassGlViewportIndexedfvNV) Schema() *schema.Class { return schemaGlViewportIndexedfvNV }

var schemaGlViewportIndexedfvNV = &schema.Class{
	TypeID:  binaryIDGlViewportIndexedfvNV,
	Package: "gles",
	Name:    "GlViewportIndexedfvNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "V", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlWaitSync struct{}

func (*GlWaitSync) Class() binary.Class {
	return (*binaryClassGlWaitSync)(nil)
}
func doEncodeGlWaitSync(e binary.Encoder, o *GlWaitSync) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.SyncFlags)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Timeout)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlWaitSync(d binary.Decoder, o *GlWaitSync) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SyncFlags = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Timeout = GLuint64(obj)
	}
	return nil
}
func doSkipGlWaitSync(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlWaitSync) ID() binary.ID      { return binaryIDGlWaitSync }
func (*binaryClassGlWaitSync) New() binary.Object { return &GlWaitSync{} }
func (*binaryClassGlWaitSync) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlWaitSync(e, obj.(*GlWaitSync))
}
func (*binaryClassGlWaitSync) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlWaitSync{}
	return obj, doDecodeGlWaitSync(d, obj)
}
func (*binaryClassGlWaitSync) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlWaitSync(d, obj.(*GlWaitSync))
}
func (*binaryClassGlWaitSync) Skip(d binary.Decoder) error { return doSkipGlWaitSync(d) }
func (*binaryClassGlWaitSync) Schema() *schema.Class       { return schemaGlWaitSync }

var schemaGlWaitSync = &schema.Class{
	TypeID:  binaryIDGlWaitSync,
	Package: "gles",
	Name:    "GlWaitSync",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "SyncFlags", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Timeout", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlWaitSyncAPPLE struct{}

func (*GlWaitSyncAPPLE) Class() binary.Class {
	return (*binaryClassGlWaitSyncAPPLE)(nil)
}
func doEncodeGlWaitSyncAPPLE(e binary.Encoder, o *GlWaitSyncAPPLE) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Sync)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Flag)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.Timeout)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlWaitSyncAPPLE(d binary.Decoder, o *GlWaitSyncAPPLE) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Sync = GLsync(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Flag = GLbitfield(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Timeout = GLuint64(obj)
	}
	return nil
}
func doSkipGlWaitSyncAPPLE(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlWaitSyncAPPLE) ID() binary.ID      { return binaryIDGlWaitSyncAPPLE }
func (*binaryClassGlWaitSyncAPPLE) New() binary.Object { return &GlWaitSyncAPPLE{} }
func (*binaryClassGlWaitSyncAPPLE) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlWaitSyncAPPLE(e, obj.(*GlWaitSyncAPPLE))
}
func (*binaryClassGlWaitSyncAPPLE) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlWaitSyncAPPLE{}
	return obj, doDecodeGlWaitSyncAPPLE(d, obj)
}
func (*binaryClassGlWaitSyncAPPLE) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlWaitSyncAPPLE(d, obj.(*GlWaitSyncAPPLE))
}
func (*binaryClassGlWaitSyncAPPLE) Skip(d binary.Decoder) error { return doSkipGlWaitSyncAPPLE(d) }
func (*binaryClassGlWaitSyncAPPLE) Schema() *schema.Class       { return schemaGlWaitSyncAPPLE }

var schemaGlWaitSyncAPPLE = &schema.Class{
	TypeID:  binaryIDGlWaitSyncAPPLE,
	Package: "gles",
	Name:    "GlWaitSyncAPPLE",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}},
		{Declared: "Flag", Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32}},
		{Declared: "Timeout", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}},
	},
}

type binaryClassGlWeightPathsNV struct{}

func (*GlWeightPathsNV) Class() binary.Class {
	return (*binaryClassGlWeightPathsNV)(nil)
}
func doEncodeGlWeightPathsNV(e binary.Encoder, o *GlWeightPathsNV) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.ResultPath)); err != nil {
		return err
	}
	if err := e.Int32(int32(o.NumPaths)); err != nil {
		return err
	}
	if err := e.Value(&o.Paths); err != nil {
		return err
	}
	if err := e.Value(&o.Weights); err != nil {
		return err
	}
	return nil
}
func doDecodeGlWeightPathsNV(d binary.Decoder, o *GlWeightPathsNV) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.ResultPath = GLuint(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.NumPaths = GLsizei(obj)
	}
	if err := d.Value(&o.Paths); err != nil {
		return err
	}
	if err := d.Value(&o.Weights); err != nil {
		return err
	}
	return nil
}
func doSkipGlWeightPathsNV(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLuintᶜᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLfloatᶜᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlWeightPathsNV) ID() binary.ID      { return binaryIDGlWeightPathsNV }
func (*binaryClassGlWeightPathsNV) New() binary.Object { return &GlWeightPathsNV{} }
func (*binaryClassGlWeightPathsNV) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlWeightPathsNV(e, obj.(*GlWeightPathsNV))
}
func (*binaryClassGlWeightPathsNV) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlWeightPathsNV{}
	return obj, doDecodeGlWeightPathsNV(d, obj)
}
func (*binaryClassGlWeightPathsNV) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlWeightPathsNV(d, obj.(*GlWeightPathsNV))
}
func (*binaryClassGlWeightPathsNV) Skip(d binary.Decoder) error { return doSkipGlWeightPathsNV(d) }
func (*binaryClassGlWeightPathsNV) Schema() *schema.Class       { return schemaGlWeightPathsNV }

var schemaGlWeightPathsNV = &schema.Class{
	TypeID:  binaryIDGlWeightPathsNV,
	Package: "gles",
	Name:    "GlWeightPathsNV",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ResultPath", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}},
		{Declared: "NumPaths", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}},
		{Declared: "Paths", Type: &schema.Struct{Name: "GLuintᶜᵖ", ID: (*GLuintᶜᵖ)(nil).Class().ID()}},
		{Declared: "Weights", Type: &schema.Struct{Name: "GLfloatᶜᵖ", ID: (*GLfloatᶜᵖ)(nil).Class().ID()}},
	},
}

type binaryClassGlXCreateContext struct{}

func (*GlXCreateContext) Class() binary.Class {
	return (*binaryClassGlXCreateContext)(nil)
}
func doEncodeGlXCreateContext(e binary.Encoder, o *GlXCreateContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Dpy); err != nil {
		return err
	}
	if err := e.Value(&o.Vis); err != nil {
		return err
	}
	if err := e.Value(&o.ShareList); err != nil {
		return err
	}
	if err := e.Bool(o.Direct); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXCreateContext(d binary.Decoder, o *GlXCreateContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Dpy); err != nil {
		return err
	}
	if err := d.Value(&o.Vis); err != nil {
		return err
	}
	if err := d.Value(&o.ShareList); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Direct = bool(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlXCreateContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXCreateContext) ID() binary.ID      { return binaryIDGlXCreateContext }
func (*binaryClassGlXCreateContext) New() binary.Object { return &GlXCreateContext{} }
func (*binaryClassGlXCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXCreateContext(e, obj.(*GlXCreateContext))
}
func (*binaryClassGlXCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXCreateContext{}
	return obj, doDecodeGlXCreateContext(d, obj)
}
func (*binaryClassGlXCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXCreateContext(d, obj.(*GlXCreateContext))
}
func (*binaryClassGlXCreateContext) Skip(d binary.Decoder) error { return doSkipGlXCreateContext(d) }
func (*binaryClassGlXCreateContext) Schema() *schema.Class       { return schemaGlXCreateContext }

var schemaGlXCreateContext = &schema.Class{
	TypeID:  binaryIDGlXCreateContext,
	Package: "gles",
	Name:    "GlXCreateContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Dpy", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Vis", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "ShareList", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
		{Declared: "Direct", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "Result", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
	},
}

type binaryClassGlXCreateNewContext struct{}

func (*GlXCreateNewContext) Class() binary.Class {
	return (*binaryClassGlXCreateNewContext)(nil)
}
func doEncodeGlXCreateNewContext(e binary.Encoder, o *GlXCreateNewContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Fbconfig); err != nil {
		return err
	}
	if err := e.Uint32(o.Type); err != nil {
		return err
	}
	if err := e.Value(&o.Shared); err != nil {
		return err
	}
	if err := e.Bool(o.Direct); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXCreateNewContext(d binary.Decoder, o *GlXCreateNewContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Fbconfig); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Type = uint32(obj)
	}
	if err := d.Value(&o.Shared); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Direct = bool(obj)
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipGlXCreateNewContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXCreateNewContext) ID() binary.ID      { return binaryIDGlXCreateNewContext }
func (*binaryClassGlXCreateNewContext) New() binary.Object { return &GlXCreateNewContext{} }
func (*binaryClassGlXCreateNewContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXCreateNewContext(e, obj.(*GlXCreateNewContext))
}
func (*binaryClassGlXCreateNewContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXCreateNewContext{}
	return obj, doDecodeGlXCreateNewContext(d, obj)
}
func (*binaryClassGlXCreateNewContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXCreateNewContext(d, obj.(*GlXCreateNewContext))
}
func (*binaryClassGlXCreateNewContext) Skip(d binary.Decoder) error {
	return doSkipGlXCreateNewContext(d)
}
func (*binaryClassGlXCreateNewContext) Schema() *schema.Class { return schemaGlXCreateNewContext }

var schemaGlXCreateNewContext = &schema.Class{
	TypeID:  binaryIDGlXCreateNewContext,
	Package: "gles",
	Name:    "GlXCreateNewContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Fbconfig", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Type", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		{Declared: "Shared", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
		{Declared: "Direct", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		{Declared: "Result", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
	},
}

type binaryClassGlXMakeContextCurrent struct{}

func (*GlXMakeContextCurrent) Class() binary.Class {
	return (*binaryClassGlXMakeContextCurrent)(nil)
}
func doEncodeGlXMakeContextCurrent(e binary.Encoder, o *GlXMakeContextCurrent) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Draw); err != nil {
		return err
	}
	if err := e.Value(&o.Read); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXMakeContextCurrent(d binary.Decoder, o *GlXMakeContextCurrent) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Draw); err != nil {
		return err
	}
	if err := d.Value(&o.Read); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = Bool(obj)
	}
	return nil
}
func doSkipGlXMakeContextCurrent(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXMakeContextCurrent) ID() binary.ID      { return binaryIDGlXMakeContextCurrent }
func (*binaryClassGlXMakeContextCurrent) New() binary.Object { return &GlXMakeContextCurrent{} }
func (*binaryClassGlXMakeContextCurrent) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXMakeContextCurrent(e, obj.(*GlXMakeContextCurrent))
}
func (*binaryClassGlXMakeContextCurrent) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXMakeContextCurrent{}
	return obj, doDecodeGlXMakeContextCurrent(d, obj)
}
func (*binaryClassGlXMakeContextCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXMakeContextCurrent(d, obj.(*GlXMakeContextCurrent))
}
func (*binaryClassGlXMakeContextCurrent) Skip(d binary.Decoder) error {
	return doSkipGlXMakeContextCurrent(d)
}
func (*binaryClassGlXMakeContextCurrent) Schema() *schema.Class { return schemaGlXMakeContextCurrent }

var schemaGlXMakeContextCurrent = &schema.Class{
	TypeID:  binaryIDGlXMakeContextCurrent,
	Package: "gles",
	Name:    "GlXMakeContextCurrent",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Draw", Type: &schema.Struct{Name: "GLXDrawable", ID: (*GLXDrawable)(nil).Class().ID()}},
		{Declared: "Read", Type: &schema.Struct{Name: "GLXDrawable", ID: (*GLXDrawable)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "Bool", Method: schema.Int64}},
	},
}

type binaryClassGlXMakeCurrent struct{}

func (*GlXMakeCurrent) Class() binary.Class {
	return (*binaryClassGlXMakeCurrent)(nil)
}
func doEncodeGlXMakeCurrent(e binary.Encoder, o *GlXMakeCurrent) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Drawable); err != nil {
		return err
	}
	if err := e.Value(&o.Ctx); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXMakeCurrent(d binary.Decoder, o *GlXMakeCurrent) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Drawable); err != nil {
		return err
	}
	if err := d.Value(&o.Ctx); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = Bool(obj)
	}
	return nil
}
func doSkipGlXMakeCurrent(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXContext)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXMakeCurrent) ID() binary.ID      { return binaryIDGlXMakeCurrent }
func (*binaryClassGlXMakeCurrent) New() binary.Object { return &GlXMakeCurrent{} }
func (*binaryClassGlXMakeCurrent) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXMakeCurrent(e, obj.(*GlXMakeCurrent))
}
func (*binaryClassGlXMakeCurrent) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXMakeCurrent{}
	return obj, doDecodeGlXMakeCurrent(d, obj)
}
func (*binaryClassGlXMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXMakeCurrent(d, obj.(*GlXMakeCurrent))
}
func (*binaryClassGlXMakeCurrent) Skip(d binary.Decoder) error { return doSkipGlXMakeCurrent(d) }
func (*binaryClassGlXMakeCurrent) Schema() *schema.Class       { return schemaGlXMakeCurrent }

var schemaGlXMakeCurrent = &schema.Class{
	TypeID:  binaryIDGlXMakeCurrent,
	Package: "gles",
	Name:    "GlXMakeCurrent",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Drawable", Type: &schema.Struct{Name: "GLXDrawable", ID: (*GLXDrawable)(nil).Class().ID()}},
		{Declared: "Ctx", Type: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "Bool", Method: schema.Int64}},
	},
}

type binaryClassIntᵖ struct{}

func (*Intᵖ) Class() binary.Class {
	return (*binaryClassIntᵖ)(nil)
}
func doEncodeIntᵖ(e binary.Encoder, o *Intᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeIntᵖ(d binary.Decoder, o *Intᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipIntᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIntᵖ) ID() binary.ID      { return binaryIDIntᵖ }
func (*binaryClassIntᵖ) New() binary.Object { return &Intᵖ{} }
func (*binaryClassIntᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIntᵖ(e, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Intᵖ{}
	return obj, doDecodeIntᵖ(d, obj)
}
func (*binaryClassIntᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIntᵖ(d, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Skip(d binary.Decoder) error { return doSkipIntᵖ(d) }
func (*binaryClassIntᵖ) Schema() *schema.Class       { return schemaIntᵖ }

var schemaIntᵖ = &schema.Class{
	TypeID:  binaryIDIntᵖ,
	Package: "gles",
	Name:    "Intᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassGlXQueryDrawable struct{}

func (*GlXQueryDrawable) Class() binary.Class {
	return (*binaryClassGlXQueryDrawable)(nil)
}
func doEncodeGlXQueryDrawable(e binary.Encoder, o *GlXQueryDrawable) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Draw); err != nil {
		return err
	}
	if err := e.Int64(o.Attribute); err != nil {
		return err
	}
	if err := e.Value(&o.Value); err != nil {
		return err
	}
	if err := e.Int64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXQueryDrawable(d binary.Decoder, o *GlXQueryDrawable) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Draw); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Attribute = int64(obj)
	}
	if err := d.Value(&o.Value); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = int64(obj)
	}
	return nil
}
func doSkipGlXQueryDrawable(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXQueryDrawable) ID() binary.ID      { return binaryIDGlXQueryDrawable }
func (*binaryClassGlXQueryDrawable) New() binary.Object { return &GlXQueryDrawable{} }
func (*binaryClassGlXQueryDrawable) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXQueryDrawable(e, obj.(*GlXQueryDrawable))
}
func (*binaryClassGlXQueryDrawable) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXQueryDrawable{}
	return obj, doDecodeGlXQueryDrawable(d, obj)
}
func (*binaryClassGlXQueryDrawable) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXQueryDrawable(d, obj.(*GlXQueryDrawable))
}
func (*binaryClassGlXQueryDrawable) Skip(d binary.Decoder) error { return doSkipGlXQueryDrawable(d) }
func (*binaryClassGlXQueryDrawable) Schema() *schema.Class       { return schemaGlXQueryDrawable }

var schemaGlXQueryDrawable = &schema.Class{
	TypeID:  binaryIDGlXQueryDrawable,
	Package: "gles",
	Name:    "GlXQueryDrawable",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Draw", Type: &schema.Struct{Name: "GLXDrawable", ID: (*GLXDrawable)(nil).Class().ID()}},
		{Declared: "Attribute", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
		{Declared: "Value", Type: &schema.Struct{Name: "Intᵖ", ID: (*Intᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassGlXSwapBuffers struct{}

func (*GlXSwapBuffers) Class() binary.Class {
	return (*binaryClassGlXSwapBuffers)(nil)
}
func doEncodeGlXSwapBuffers(e binary.Encoder, o *GlXSwapBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Display); err != nil {
		return err
	}
	if err := e.Value(&o.Drawable); err != nil {
		return err
	}
	return nil
}
func doDecodeGlXSwapBuffers(d binary.Decoder, o *GlXSwapBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Display); err != nil {
		return err
	}
	if err := d.Value(&o.Drawable); err != nil {
		return err
	}
	return nil
}
func doSkipGlXSwapBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*GLXDrawable)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassGlXSwapBuffers) ID() binary.ID      { return binaryIDGlXSwapBuffers }
func (*binaryClassGlXSwapBuffers) New() binary.Object { return &GlXSwapBuffers{} }
func (*binaryClassGlXSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeGlXSwapBuffers(e, obj.(*GlXSwapBuffers))
}
func (*binaryClassGlXSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &GlXSwapBuffers{}
	return obj, doDecodeGlXSwapBuffers(d, obj)
}
func (*binaryClassGlXSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeGlXSwapBuffers(d, obj.(*GlXSwapBuffers))
}
func (*binaryClassGlXSwapBuffers) Skip(d binary.Decoder) error { return doSkipGlXSwapBuffers(d) }
func (*binaryClassGlXSwapBuffers) Schema() *schema.Class       { return schemaGlXSwapBuffers }

var schemaGlXSwapBuffers = &schema.Class{
	TypeID:  binaryIDGlXSwapBuffers,
	Package: "gles",
	Name:    "GlXSwapBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Display", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
		{Declared: "Drawable", Type: &schema.Struct{Name: "GLXDrawable", ID: (*GLXDrawable)(nil).Class().ID()}},
	},
}

type binaryClassHDC struct{}

func (*HDC) Class() binary.Class {
	return (*binaryClassHDC)(nil)
}
func doEncodeHDC(e binary.Encoder, o *HDC) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeHDC(d binary.Decoder, o *HDC) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipHDC(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassHDC) ID() binary.ID      { return binaryIDHDC }
func (*binaryClassHDC) New() binary.Object { return &HDC{} }
func (*binaryClassHDC) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeHDC(e, obj.(*HDC))
}
func (*binaryClassHDC) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &HDC{}
	return obj, doDecodeHDC(d, obj)
}
func (*binaryClassHDC) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeHDC(d, obj.(*HDC))
}
func (*binaryClassHDC) Skip(d binary.Decoder) error { return doSkipHDC(d) }
func (*binaryClassHDC) Schema() *schema.Class       { return schemaHDC }

var schemaHDC = &schema.Class{
	TypeID:  binaryIDHDC,
	Package: "gles",
	Name:    "HDC",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassHGLRC struct{}

func (*HGLRC) Class() binary.Class {
	return (*binaryClassHGLRC)(nil)
}
func doEncodeHGLRC(e binary.Encoder, o *HGLRC) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeHGLRC(d binary.Decoder, o *HGLRC) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipHGLRC(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassHGLRC) ID() binary.ID      { return binaryIDHGLRC }
func (*binaryClassHGLRC) New() binary.Object { return &HGLRC{} }
func (*binaryClassHGLRC) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeHGLRC(e, obj.(*HGLRC))
}
func (*binaryClassHGLRC) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &HGLRC{}
	return obj, doDecodeHGLRC(d, obj)
}
func (*binaryClassHGLRC) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeHGLRC(d, obj.(*HGLRC))
}
func (*binaryClassHGLRC) Skip(d binary.Decoder) error { return doSkipHGLRC(d) }
func (*binaryClassHGLRC) Schema() *schema.Class       { return schemaHGLRC }

var schemaHGLRC = &schema.Class{
	TypeID:  binaryIDHGLRC,
	Package: "gles",
	Name:    "HGLRC",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassIntˢ struct{}

func (*Intˢ) Class() binary.Class {
	return (*binaryClassIntˢ)(nil)
}
func doEncodeIntˢ(e binary.Encoder, o *Intˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeIntˢ(d binary.Decoder, o *Intˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipIntˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIntˢ) ID() binary.ID      { return binaryIDIntˢ }
func (*binaryClassIntˢ) New() binary.Object { return &Intˢ{} }
func (*binaryClassIntˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIntˢ(e, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Intˢ{}
	return obj, doDecodeIntˢ(d, obj)
}
func (*binaryClassIntˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIntˢ(d, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Skip(d binary.Decoder) error { return doSkipIntˢ(d) }
func (*binaryClassIntˢ) Schema() *schema.Class       { return schemaIntˢ }

var schemaIntˢ = &schema.Class{
	TypeID:  binaryIDIntˢ,
	Package: "gles",
	Name:    "Intˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec2f struct{}

func (*Vec2f) Class() binary.Class {
	return (*binaryClassVec2f)(nil)
}
func doEncodeVec2f(e binary.Encoder, o *Vec2f) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec2f(d binary.Decoder, o *Vec2f) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipVec2f(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec2f) ID() binary.ID      { return binaryIDVec2f }
func (*binaryClassVec2f) New() binary.Object { return &Vec2f{} }
func (*binaryClassVec2f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2f(e, obj.(*Vec2f))
}
func (*binaryClassVec2f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2f{}
	return obj, doDecodeVec2f(d, obj)
}
func (*binaryClassVec2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2f(d, obj.(*Vec2f))
}
func (*binaryClassVec2f) Skip(d binary.Decoder) error { return doSkipVec2f(d) }
func (*binaryClassVec2f) Schema() *schema.Class       { return schemaVec2f }

var schemaVec2f = &schema.Class{
	TypeID:  binaryIDVec2f,
	Package: "gles",
	Name:    "Vec2f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 2}},
	},
}

type binaryClassMat2f struct{}

func (*Mat2f) Class() binary.Class {
	return (*binaryClassMat2f)(nil)
}
func doEncodeMat2f(e binary.Encoder, o *Mat2f) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeMat2f(d binary.Decoder, o *Mat2f) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipMat2f(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if err := d.SkipValue((*Vec2f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassMat2f) ID() binary.ID      { return binaryIDMat2f }
func (*binaryClassMat2f) New() binary.Object { return &Mat2f{} }
func (*binaryClassMat2f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat2f(e, obj.(*Mat2f))
}
func (*binaryClassMat2f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat2f{}
	return obj, doDecodeMat2f(d, obj)
}
func (*binaryClassMat2f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat2f(d, obj.(*Mat2f))
}
func (*binaryClassMat2f) Skip(d binary.Decoder) error { return doSkipMat2f(d) }
func (*binaryClassMat2f) Schema() *schema.Class       { return schemaMat2f }

var schemaMat2f = &schema.Class{
	TypeID:  binaryIDMat2f,
	Package: "gles",
	Name:    "Mat2f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec2f", ID: (*Vec2f)(nil).Class().ID()}, Size: 2}},
	},
}

type binaryClassMat2fˢ struct{}

func (*Mat2fˢ) Class() binary.Class {
	return (*binaryClassMat2fˢ)(nil)
}
func doEncodeMat2fˢ(e binary.Encoder, o *Mat2fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeMat2fˢ(d binary.Decoder, o *Mat2fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipMat2fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat2fˢ) ID() binary.ID      { return binaryIDMat2fˢ }
func (*binaryClassMat2fˢ) New() binary.Object { return &Mat2fˢ{} }
func (*binaryClassMat2fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat2fˢ(e, obj.(*Mat2fˢ))
}
func (*binaryClassMat2fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat2fˢ{}
	return obj, doDecodeMat2fˢ(d, obj)
}
func (*binaryClassMat2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat2fˢ(d, obj.(*Mat2fˢ))
}
func (*binaryClassMat2fˢ) Skip(d binary.Decoder) error { return doSkipMat2fˢ(d) }
func (*binaryClassMat2fˢ) Schema() *schema.Class       { return schemaMat2fˢ }

var schemaMat2fˢ = &schema.Class{
	TypeID:  binaryIDMat2fˢ,
	Package: "gles",
	Name:    "Mat2fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassMat2fᵖ struct{}

func (*Mat2fᵖ) Class() binary.Class {
	return (*binaryClassMat2fᵖ)(nil)
}
func doEncodeMat2fᵖ(e binary.Encoder, o *Mat2fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeMat2fᵖ(d binary.Decoder, o *Mat2fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipMat2fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat2fᵖ) ID() binary.ID      { return binaryIDMat2fᵖ }
func (*binaryClassMat2fᵖ) New() binary.Object { return &Mat2fᵖ{} }
func (*binaryClassMat2fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat2fᵖ(e, obj.(*Mat2fᵖ))
}
func (*binaryClassMat2fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat2fᵖ{}
	return obj, doDecodeMat2fᵖ(d, obj)
}
func (*binaryClassMat2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat2fᵖ(d, obj.(*Mat2fᵖ))
}
func (*binaryClassMat2fᵖ) Skip(d binary.Decoder) error { return doSkipMat2fᵖ(d) }
func (*binaryClassMat2fᵖ) Schema() *schema.Class       { return schemaMat2fᵖ }

var schemaMat2fᵖ = &schema.Class{
	TypeID:  binaryIDMat2fᵖ,
	Package: "gles",
	Name:    "Mat2fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec3f struct{}

func (*Vec3f) Class() binary.Class {
	return (*binaryClassVec3f)(nil)
}
func doEncodeVec3f(e binary.Encoder, o *Vec3f) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec3f(d binary.Decoder, o *Vec3f) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipVec3f(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec3f) ID() binary.ID      { return binaryIDVec3f }
func (*binaryClassVec3f) New() binary.Object { return &Vec3f{} }
func (*binaryClassVec3f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3f(e, obj.(*Vec3f))
}
func (*binaryClassVec3f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3f{}
	return obj, doDecodeVec3f(d, obj)
}
func (*binaryClassVec3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3f(d, obj.(*Vec3f))
}
func (*binaryClassVec3f) Skip(d binary.Decoder) error { return doSkipVec3f(d) }
func (*binaryClassVec3f) Schema() *schema.Class       { return schemaVec3f }

var schemaVec3f = &schema.Class{
	TypeID:  binaryIDVec3f,
	Package: "gles",
	Name:    "Vec3f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 3}},
	},
}

type binaryClassMat3f struct{}

func (*Mat3f) Class() binary.Class {
	return (*binaryClassMat3f)(nil)
}
func doEncodeMat3f(e binary.Encoder, o *Mat3f) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeMat3f(d binary.Decoder, o *Mat3f) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipMat3f(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if err := d.SkipValue((*Vec3f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassMat3f) ID() binary.ID      { return binaryIDMat3f }
func (*binaryClassMat3f) New() binary.Object { return &Mat3f{} }
func (*binaryClassMat3f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat3f(e, obj.(*Mat3f))
}
func (*binaryClassMat3f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat3f{}
	return obj, doDecodeMat3f(d, obj)
}
func (*binaryClassMat3f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat3f(d, obj.(*Mat3f))
}
func (*binaryClassMat3f) Skip(d binary.Decoder) error { return doSkipMat3f(d) }
func (*binaryClassMat3f) Schema() *schema.Class       { return schemaMat3f }

var schemaMat3f = &schema.Class{
	TypeID:  binaryIDMat3f,
	Package: "gles",
	Name:    "Mat3f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec3f", ID: (*Vec3f)(nil).Class().ID()}, Size: 3}},
	},
}

type binaryClassMat3fˢ struct{}

func (*Mat3fˢ) Class() binary.Class {
	return (*binaryClassMat3fˢ)(nil)
}
func doEncodeMat3fˢ(e binary.Encoder, o *Mat3fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeMat3fˢ(d binary.Decoder, o *Mat3fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipMat3fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat3fˢ) ID() binary.ID      { return binaryIDMat3fˢ }
func (*binaryClassMat3fˢ) New() binary.Object { return &Mat3fˢ{} }
func (*binaryClassMat3fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat3fˢ(e, obj.(*Mat3fˢ))
}
func (*binaryClassMat3fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat3fˢ{}
	return obj, doDecodeMat3fˢ(d, obj)
}
func (*binaryClassMat3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat3fˢ(d, obj.(*Mat3fˢ))
}
func (*binaryClassMat3fˢ) Skip(d binary.Decoder) error { return doSkipMat3fˢ(d) }
func (*binaryClassMat3fˢ) Schema() *schema.Class       { return schemaMat3fˢ }

var schemaMat3fˢ = &schema.Class{
	TypeID:  binaryIDMat3fˢ,
	Package: "gles",
	Name:    "Mat3fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassMat3fᵖ struct{}

func (*Mat3fᵖ) Class() binary.Class {
	return (*binaryClassMat3fᵖ)(nil)
}
func doEncodeMat3fᵖ(e binary.Encoder, o *Mat3fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeMat3fᵖ(d binary.Decoder, o *Mat3fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipMat3fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat3fᵖ) ID() binary.ID      { return binaryIDMat3fᵖ }
func (*binaryClassMat3fᵖ) New() binary.Object { return &Mat3fᵖ{} }
func (*binaryClassMat3fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat3fᵖ(e, obj.(*Mat3fᵖ))
}
func (*binaryClassMat3fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat3fᵖ{}
	return obj, doDecodeMat3fᵖ(d, obj)
}
func (*binaryClassMat3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat3fᵖ(d, obj.(*Mat3fᵖ))
}
func (*binaryClassMat3fᵖ) Skip(d binary.Decoder) error { return doSkipMat3fᵖ(d) }
func (*binaryClassMat3fᵖ) Schema() *schema.Class       { return schemaMat3fᵖ }

var schemaMat3fᵖ = &schema.Class{
	TypeID:  binaryIDMat3fᵖ,
	Package: "gles",
	Name:    "Mat3fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec4f struct{}

func (*Vec4f) Class() binary.Class {
	return (*binaryClassVec4f)(nil)
}
func doEncodeVec4f(e binary.Encoder, o *Vec4f) error {
	for i := range o.Elements {
		if err := e.Float32(float32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec4f(d binary.Decoder, o *Vec4f) error {
	for i := range o.Elements {
		if obj, err := d.Float32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLfloat(obj)
		}
	}
	return nil
}
func doSkipVec4f(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if _, err := d.Float32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec4f) ID() binary.ID      { return binaryIDVec4f }
func (*binaryClassVec4f) New() binary.Object { return &Vec4f{} }
func (*binaryClassVec4f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4f(e, obj.(*Vec4f))
}
func (*binaryClassVec4f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4f{}
	return obj, doDecodeVec4f(d, obj)
}
func (*binaryClassVec4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4f(d, obj.(*Vec4f))
}
func (*binaryClassVec4f) Skip(d binary.Decoder) error { return doSkipVec4f(d) }
func (*binaryClassVec4f) Schema() *schema.Class       { return schemaVec4f }

var schemaVec4f = &schema.Class{
	TypeID:  binaryIDVec4f,
	Package: "gles",
	Name:    "Vec4f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}, Size: 4}},
	},
}

type binaryClassMat4f struct{}

func (*Mat4f) Class() binary.Class {
	return (*binaryClassMat4f)(nil)
}
func doEncodeMat4f(e binary.Encoder, o *Mat4f) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeMat4f(d binary.Decoder, o *Mat4f) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipMat4f(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if err := d.SkipValue((*Vec4f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassMat4f) ID() binary.ID      { return binaryIDMat4f }
func (*binaryClassMat4f) New() binary.Object { return &Mat4f{} }
func (*binaryClassMat4f) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat4f(e, obj.(*Mat4f))
}
func (*binaryClassMat4f) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat4f{}
	return obj, doDecodeMat4f(d, obj)
}
func (*binaryClassMat4f) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat4f(d, obj.(*Mat4f))
}
func (*binaryClassMat4f) Skip(d binary.Decoder) error { return doSkipMat4f(d) }
func (*binaryClassMat4f) Schema() *schema.Class       { return schemaMat4f }

var schemaMat4f = &schema.Class{
	TypeID:  binaryIDMat4f,
	Package: "gles",
	Name:    "Mat4f",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec4f", ID: (*Vec4f)(nil).Class().ID()}, Size: 4}},
	},
}

type binaryClassMat4fˢ struct{}

func (*Mat4fˢ) Class() binary.Class {
	return (*binaryClassMat4fˢ)(nil)
}
func doEncodeMat4fˢ(e binary.Encoder, o *Mat4fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeMat4fˢ(d binary.Decoder, o *Mat4fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipMat4fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat4fˢ) ID() binary.ID      { return binaryIDMat4fˢ }
func (*binaryClassMat4fˢ) New() binary.Object { return &Mat4fˢ{} }
func (*binaryClassMat4fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat4fˢ(e, obj.(*Mat4fˢ))
}
func (*binaryClassMat4fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat4fˢ{}
	return obj, doDecodeMat4fˢ(d, obj)
}
func (*binaryClassMat4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat4fˢ(d, obj.(*Mat4fˢ))
}
func (*binaryClassMat4fˢ) Skip(d binary.Decoder) error { return doSkipMat4fˢ(d) }
func (*binaryClassMat4fˢ) Schema() *schema.Class       { return schemaMat4fˢ }

var schemaMat4fˢ = &schema.Class{
	TypeID:  binaryIDMat4fˢ,
	Package: "gles",
	Name:    "Mat4fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassMat4fᵖ struct{}

func (*Mat4fᵖ) Class() binary.Class {
	return (*binaryClassMat4fᵖ)(nil)
}
func doEncodeMat4fᵖ(e binary.Encoder, o *Mat4fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeMat4fᵖ(d binary.Decoder, o *Mat4fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipMat4fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMat4fᵖ) ID() binary.ID      { return binaryIDMat4fᵖ }
func (*binaryClassMat4fᵖ) New() binary.Object { return &Mat4fᵖ{} }
func (*binaryClassMat4fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMat4fᵖ(e, obj.(*Mat4fᵖ))
}
func (*binaryClassMat4fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Mat4fᵖ{}
	return obj, doDecodeMat4fᵖ(d, obj)
}
func (*binaryClassMat4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMat4fᵖ(d, obj.(*Mat4fᵖ))
}
func (*binaryClassMat4fᵖ) Skip(d binary.Decoder) error { return doSkipMat4fᵖ(d) }
func (*binaryClassMat4fᵖ) Schema() *schema.Class       { return schemaMat4fᵖ }

var schemaMat4fᵖ = &schema.Class{
	TypeID:  binaryIDMat4fᵖ,
	Package: "gles",
	Name:    "Mat4fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassPipelineIdˢ struct{}

func (*PipelineIdˢ) Class() binary.Class {
	return (*binaryClassPipelineIdˢ)(nil)
}
func doEncodePipelineIdˢ(e binary.Encoder, o *PipelineIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodePipelineIdˢ(d binary.Decoder, o *PipelineIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipPipelineIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassPipelineIdˢ) ID() binary.ID      { return binaryIDPipelineIdˢ }
func (*binaryClassPipelineIdˢ) New() binary.Object { return &PipelineIdˢ{} }
func (*binaryClassPipelineIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodePipelineIdˢ(e, obj.(*PipelineIdˢ))
}
func (*binaryClassPipelineIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &PipelineIdˢ{}
	return obj, doDecodePipelineIdˢ(d, obj)
}
func (*binaryClassPipelineIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodePipelineIdˢ(d, obj.(*PipelineIdˢ))
}
func (*binaryClassPipelineIdˢ) Skip(d binary.Decoder) error { return doSkipPipelineIdˢ(d) }
func (*binaryClassPipelineIdˢ) Schema() *schema.Class       { return schemaPipelineIdˢ }

var schemaPipelineIdˢ = &schema.Class{
	TypeID:  binaryIDPipelineIdˢ,
	Package: "gles",
	Name:    "PipelineIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassProgramIdˢ struct{}

func (*ProgramIdˢ) Class() binary.Class {
	return (*binaryClassProgramIdˢ)(nil)
}
func doEncodeProgramIdˢ(e binary.Encoder, o *ProgramIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeProgramIdˢ(d binary.Decoder, o *ProgramIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipProgramIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassProgramIdˢ) ID() binary.ID      { return binaryIDProgramIdˢ }
func (*binaryClassProgramIdˢ) New() binary.Object { return &ProgramIdˢ{} }
func (*binaryClassProgramIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeProgramIdˢ(e, obj.(*ProgramIdˢ))
}
func (*binaryClassProgramIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ProgramIdˢ{}
	return obj, doDecodeProgramIdˢ(d, obj)
}
func (*binaryClassProgramIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeProgramIdˢ(d, obj.(*ProgramIdˢ))
}
func (*binaryClassProgramIdˢ) Skip(d binary.Decoder) error { return doSkipProgramIdˢ(d) }
func (*binaryClassProgramIdˢ) Schema() *schema.Class       { return schemaProgramIdˢ }

var schemaProgramIdˢ = &schema.Class{
	TypeID:  binaryIDProgramIdˢ,
	Package: "gles",
	Name:    "ProgramIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassQueryIdˢ struct{}

func (*QueryIdˢ) Class() binary.Class {
	return (*binaryClassQueryIdˢ)(nil)
}
func doEncodeQueryIdˢ(e binary.Encoder, o *QueryIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeQueryIdˢ(d binary.Decoder, o *QueryIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipQueryIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassQueryIdˢ) ID() binary.ID      { return binaryIDQueryIdˢ }
func (*binaryClassQueryIdˢ) New() binary.Object { return &QueryIdˢ{} }
func (*binaryClassQueryIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeQueryIdˢ(e, obj.(*QueryIdˢ))
}
func (*binaryClassQueryIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &QueryIdˢ{}
	return obj, doDecodeQueryIdˢ(d, obj)
}
func (*binaryClassQueryIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeQueryIdˢ(d, obj.(*QueryIdˢ))
}
func (*binaryClassQueryIdˢ) Skip(d binary.Decoder) error { return doSkipQueryIdˢ(d) }
func (*binaryClassQueryIdˢ) Schema() *schema.Class       { return schemaQueryIdˢ }

var schemaQueryIdˢ = &schema.Class{
	TypeID:  binaryIDQueryIdˢ,
	Package: "gles",
	Name:    "QueryIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassRenderbufferIdˢ struct{}

func (*RenderbufferIdˢ) Class() binary.Class {
	return (*binaryClassRenderbufferIdˢ)(nil)
}
func doEncodeRenderbufferIdˢ(e binary.Encoder, o *RenderbufferIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderbufferIdˢ(d binary.Decoder, o *RenderbufferIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipRenderbufferIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderbufferIdˢ) ID() binary.ID      { return binaryIDRenderbufferIdˢ }
func (*binaryClassRenderbufferIdˢ) New() binary.Object { return &RenderbufferIdˢ{} }
func (*binaryClassRenderbufferIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderbufferIdˢ(e, obj.(*RenderbufferIdˢ))
}
func (*binaryClassRenderbufferIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderbufferIdˢ{}
	return obj, doDecodeRenderbufferIdˢ(d, obj)
}
func (*binaryClassRenderbufferIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderbufferIdˢ(d, obj.(*RenderbufferIdˢ))
}
func (*binaryClassRenderbufferIdˢ) Skip(d binary.Decoder) error { return doSkipRenderbufferIdˢ(d) }
func (*binaryClassRenderbufferIdˢ) Schema() *schema.Class       { return schemaRenderbufferIdˢ }

var schemaRenderbufferIdˢ = &schema.Class{
	TypeID:  binaryIDRenderbufferIdˢ,
	Package: "gles",
	Name:    "RenderbufferIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassReplayBindRenderer struct{}

func (*ReplayBindRenderer) Class() binary.Class {
	return (*binaryClassReplayBindRenderer)(nil)
}
func doEncodeReplayBindRenderer(e binary.Encoder, o *ReplayBindRenderer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.Id); err != nil {
		return err
	}
	return nil
}
func doDecodeReplayBindRenderer(d binary.Decoder, o *ReplayBindRenderer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = uint32(obj)
	}
	return nil
}
func doSkipReplayBindRenderer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassReplayBindRenderer) ID() binary.ID      { return binaryIDReplayBindRenderer }
func (*binaryClassReplayBindRenderer) New() binary.Object { return &ReplayBindRenderer{} }
func (*binaryClassReplayBindRenderer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeReplayBindRenderer(e, obj.(*ReplayBindRenderer))
}
func (*binaryClassReplayBindRenderer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ReplayBindRenderer{}
	return obj, doDecodeReplayBindRenderer(d, obj)
}
func (*binaryClassReplayBindRenderer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeReplayBindRenderer(d, obj.(*ReplayBindRenderer))
}
func (*binaryClassReplayBindRenderer) Skip(d binary.Decoder) error { return doSkipReplayBindRenderer(d) }
func (*binaryClassReplayBindRenderer) Schema() *schema.Class       { return schemaReplayBindRenderer }

var schemaReplayBindRenderer = &schema.Class{
	TypeID:  binaryIDReplayBindRenderer,
	Package: "gles",
	Name:    "ReplayBindRenderer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Id", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassReplayCreateRenderer struct{}

func (*ReplayCreateRenderer) Class() binary.Class {
	return (*binaryClassReplayCreateRenderer)(nil)
}
func doEncodeReplayCreateRenderer(e binary.Encoder, o *ReplayCreateRenderer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.Id); err != nil {
		return err
	}
	return nil
}
func doDecodeReplayCreateRenderer(d binary.Decoder, o *ReplayCreateRenderer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Id = uint32(obj)
	}
	return nil
}
func doSkipReplayCreateRenderer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassReplayCreateRenderer) ID() binary.ID      { return binaryIDReplayCreateRenderer }
func (*binaryClassReplayCreateRenderer) New() binary.Object { return &ReplayCreateRenderer{} }
func (*binaryClassReplayCreateRenderer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeReplayCreateRenderer(e, obj.(*ReplayCreateRenderer))
}
func (*binaryClassReplayCreateRenderer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ReplayCreateRenderer{}
	return obj, doDecodeReplayCreateRenderer(d, obj)
}
func (*binaryClassReplayCreateRenderer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeReplayCreateRenderer(d, obj.(*ReplayCreateRenderer))
}
func (*binaryClassReplayCreateRenderer) Skip(d binary.Decoder) error {
	return doSkipReplayCreateRenderer(d)
}
func (*binaryClassReplayCreateRenderer) Schema() *schema.Class { return schemaReplayCreateRenderer }

var schemaReplayCreateRenderer = &schema.Class{
	TypeID:  binaryIDReplayCreateRenderer,
	Package: "gles",
	Name:    "ReplayCreateRenderer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Id", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassS64ˢ struct{}

func (*S64ˢ) Class() binary.Class {
	return (*binaryClassS64ˢ)(nil)
}
func doEncodeS64ˢ(e binary.Encoder, o *S64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeS64ˢ(d binary.Decoder, o *S64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipS64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS64ˢ) ID() binary.ID      { return binaryIDS64ˢ }
func (*binaryClassS64ˢ) New() binary.Object { return &S64ˢ{} }
func (*binaryClassS64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS64ˢ(e, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S64ˢ{}
	return obj, doDecodeS64ˢ(d, obj)
}
func (*binaryClassS64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS64ˢ(d, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Skip(d binary.Decoder) error { return doSkipS64ˢ(d) }
func (*binaryClassS64ˢ) Schema() *schema.Class       { return schemaS64ˢ }

var schemaS64ˢ = &schema.Class{
	TypeID:  binaryIDS64ˢ,
	Package: "gles",
	Name:    "S64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassSamplerIdˢ struct{}

func (*SamplerIdˢ) Class() binary.Class {
	return (*binaryClassSamplerIdˢ)(nil)
}
func doEncodeSamplerIdˢ(e binary.Encoder, o *SamplerIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeSamplerIdˢ(d binary.Decoder, o *SamplerIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipSamplerIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSamplerIdˢ) ID() binary.ID      { return binaryIDSamplerIdˢ }
func (*binaryClassSamplerIdˢ) New() binary.Object { return &SamplerIdˢ{} }
func (*binaryClassSamplerIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSamplerIdˢ(e, obj.(*SamplerIdˢ))
}
func (*binaryClassSamplerIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SamplerIdˢ{}
	return obj, doDecodeSamplerIdˢ(d, obj)
}
func (*binaryClassSamplerIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSamplerIdˢ(d, obj.(*SamplerIdˢ))
}
func (*binaryClassSamplerIdˢ) Skip(d binary.Decoder) error { return doSkipSamplerIdˢ(d) }
func (*binaryClassSamplerIdˢ) Schema() *schema.Class       { return schemaSamplerIdˢ }

var schemaSamplerIdˢ = &schema.Class{
	TypeID:  binaryIDSamplerIdˢ,
	Package: "gles",
	Name:    "SamplerIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassShaderIdˢ struct{}

func (*ShaderIdˢ) Class() binary.Class {
	return (*binaryClassShaderIdˢ)(nil)
}
func doEncodeShaderIdˢ(e binary.Encoder, o *ShaderIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeShaderIdˢ(d binary.Decoder, o *ShaderIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipShaderIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassShaderIdˢ) ID() binary.ID      { return binaryIDShaderIdˢ }
func (*binaryClassShaderIdˢ) New() binary.Object { return &ShaderIdˢ{} }
func (*binaryClassShaderIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeShaderIdˢ(e, obj.(*ShaderIdˢ))
}
func (*binaryClassShaderIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ShaderIdˢ{}
	return obj, doDecodeShaderIdˢ(d, obj)
}
func (*binaryClassShaderIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeShaderIdˢ(d, obj.(*ShaderIdˢ))
}
func (*binaryClassShaderIdˢ) Skip(d binary.Decoder) error { return doSkipShaderIdˢ(d) }
func (*binaryClassShaderIdˢ) Schema() *schema.Class       { return schemaShaderIdˢ }

var schemaShaderIdˢ = &schema.Class{
	TypeID:  binaryIDShaderIdˢ,
	Package: "gles",
	Name:    "ShaderIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassStartTimer struct{}

func (*StartTimer) Class() binary.Class {
	return (*binaryClassStartTimer)(nil)
}
func doEncodeStartTimer(e binary.Encoder, o *StartTimer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(o.Index); err != nil {
		return err
	}
	return nil
}
func doDecodeStartTimer(d binary.Decoder, o *StartTimer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Index = uint8(obj)
	}
	return nil
}
func doSkipStartTimer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassStartTimer) ID() binary.ID      { return binaryIDStartTimer }
func (*binaryClassStartTimer) New() binary.Object { return &StartTimer{} }
func (*binaryClassStartTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeStartTimer(e, obj.(*StartTimer))
}
func (*binaryClassStartTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &StartTimer{}
	return obj, doDecodeStartTimer(d, obj)
}
func (*binaryClassStartTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeStartTimer(d, obj.(*StartTimer))
}
func (*binaryClassStartTimer) Skip(d binary.Decoder) error { return doSkipStartTimer(d) }
func (*binaryClassStartTimer) Schema() *schema.Class       { return schemaStartTimer }

var schemaStartTimer = &schema.Class{
	TypeID:  binaryIDStartTimer,
	Package: "gles",
	Name:    "StartTimer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
	},
}

type binaryClassState struct{}

func (*State) Class() binary.Class {
	return (*binaryClassState)(nil)
}
func doEncodeState(e binary.Encoder, o *State) error {
	if err := e.Uint32(uint32(o.NextContextID)); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.CurrentThread)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Contexts))); err != nil {
		return err
	}
	for k, v := range o.Contexts {
		if err := e.Uint64(uint64(k)); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.EGLContexts))); err != nil {
		return err
	}
	for k, v := range o.EGLContexts {
		if err := e.Value(&k); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.GLXContexts))); err != nil {
		return err
	}
	for k, v := range o.GLXContexts {
		if err := e.Value(&k); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.WGLContexts))); err != nil {
		return err
	}
	for k, v := range o.WGLContexts {
		if err := e.Value(&k); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.CGLContexts))); err != nil {
		return err
	}
	for k, v := range o.CGLContexts {
		if err := e.Value(&k); err != nil {
			return err
		}
		if v != nil {
			if err := e.Object(v); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeState(d binary.Decoder, o *State) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.NextContextID = ContextID(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.CurrentThread = ThreadID(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Contexts = make(ThreadIDːContextʳᵐ, count)
		m := o.Contexts
		for i := uint32(0); i < count; i++ {
			var k ThreadID
			var v *Context
			if obj, err := d.Uint64(); err != nil {
				return err
			} else {
				k = ThreadID(obj)
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.EGLContexts = make(EGLContextːContextʳᵐ, count)
		m := o.EGLContexts
		for i := uint32(0); i < count; i++ {
			var k EGLContext
			var v *Context
			if err := d.Value(&k); err != nil {
				return err
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.GLXContexts = make(GLXContextːContextʳᵐ, count)
		m := o.GLXContexts
		for i := uint32(0); i < count; i++ {
			var k GLXContext
			var v *Context
			if err := d.Value(&k); err != nil {
				return err
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.WGLContexts = make(HGLRCːContextʳᵐ, count)
		m := o.WGLContexts
		for i := uint32(0); i < count; i++ {
			var k HGLRC
			var v *Context
			if err := d.Value(&k); err != nil {
				return err
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.CGLContexts = make(CGLContextObjːContextʳᵐ, count)
		m := o.CGLContexts
		for i := uint32(0); i < count; i++ {
			var k CGLContextObj
			var v *Context
			if err := d.Value(&k); err != nil {
				return err
			}
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				v = obj.(*Context)
			} else {
				v = nil
			}
			m[k] = v
		}
	}
	return nil
}
func doSkipState(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint64(); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*EGLContext)(nil)); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*GLXContext)(nil)); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*HGLRC)(nil)); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*CGLContextObj)(nil)); err != nil {
				return err
			}
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassState) ID() binary.ID      { return binaryIDState }
func (*binaryClassState) New() binary.Object { return &State{} }
func (*binaryClassState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeState(e, obj.(*State))
}
func (*binaryClassState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &State{}
	return obj, doDecodeState(d, obj)
}
func (*binaryClassState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeState(d, obj.(*State))
}
func (*binaryClassState) Skip(d binary.Decoder) error { return doSkipState(d) }
func (*binaryClassState) Schema() *schema.Class       { return schemaState }

var schemaState = &schema.Class{
	TypeID:  binaryIDState,
	Package: "gles",
	Name:    "State",
	Fields: []schema.Field{
		{Declared: "NextContextID", Type: &schema.Primitive{Name: "ContextID", Method: schema.Uint32}},
		{Declared: "CurrentThread", Type: &schema.Primitive{Name: "ThreadID", Method: schema.Uint64}},
		{Declared: "Contexts", Type: &schema.Map{Alias: "ThreadIDːContextʳᵐ", KeyType: &schema.Primitive{Name: "ThreadID", Method: schema.Uint64}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context", ID: (*Context)(nil).Class().ID()}}}},
		{Declared: "EGLContexts", Type: &schema.Map{Alias: "EGLContextːContextʳᵐ", KeyType: &schema.Struct{Name: "EGLContext", ID: (*EGLContext)(nil).Class().ID()}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context", ID: (*Context)(nil).Class().ID()}}}},
		{Declared: "GLXContexts", Type: &schema.Map{Alias: "GLXContextːContextʳᵐ", KeyType: &schema.Struct{Name: "GLXContext", ID: (*GLXContext)(nil).Class().ID()}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context", ID: (*Context)(nil).Class().ID()}}}},
		{Declared: "WGLContexts", Type: &schema.Map{Alias: "HGLRCːContextʳᵐ", KeyType: &schema.Struct{Name: "HGLRC", ID: (*HGLRC)(nil).Class().ID()}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context", ID: (*Context)(nil).Class().ID()}}}},
		{Declared: "CGLContexts", Type: &schema.Map{Alias: "CGLContextObjːContextʳᵐ", KeyType: &schema.Struct{Name: "CGLContextObj", ID: (*CGLContextObj)(nil).Class().ID()}, ValueType: &schema.Pointer{Type: &schema.Struct{Name: "Context", ID: (*Context)(nil).Class().ID()}}}},
	},
}

type binaryClassStopTimer struct{}

func (*StopTimer) Class() binary.Class {
	return (*binaryClassStopTimer)(nil)
}
func doEncodeStopTimer(e binary.Encoder, o *StopTimer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(o.Index); err != nil {
		return err
	}
	if err := e.Uint64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeStopTimer(d binary.Decoder, o *StopTimer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Index = uint8(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = uint64(obj)
	}
	return nil
}
func doSkipStopTimer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassStopTimer) ID() binary.ID      { return binaryIDStopTimer }
func (*binaryClassStopTimer) New() binary.Object { return &StopTimer{} }
func (*binaryClassStopTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeStopTimer(e, obj.(*StopTimer))
}
func (*binaryClassStopTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &StopTimer{}
	return obj, doDecodeStopTimer(d, obj)
}
func (*binaryClassStopTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeStopTimer(d, obj.(*StopTimer))
}
func (*binaryClassStopTimer) Skip(d binary.Decoder) error { return doSkipStopTimer(d) }
func (*binaryClassStopTimer) Schema() *schema.Class       { return schemaStopTimer }

var schemaStopTimer = &schema.Class{
	TypeID:  binaryIDStopTimer,
	Package: "gles",
	Name:    "StopTimer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Index", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		{Declared: "Result", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassSwitchThread struct{}

func (*SwitchThread) Class() binary.Class {
	return (*binaryClassSwitchThread)(nil)
}
func doEncodeSwitchThread(e binary.Encoder, o *SwitchThread) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(uint64(o.ThreadID)); err != nil {
		return err
	}
	return nil
}
func doDecodeSwitchThread(d binary.Decoder, o *SwitchThread) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.ThreadID = ThreadID(obj)
	}
	return nil
}
func doSkipSwitchThread(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSwitchThread) ID() binary.ID      { return binaryIDSwitchThread }
func (*binaryClassSwitchThread) New() binary.Object { return &SwitchThread{} }
func (*binaryClassSwitchThread) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSwitchThread(e, obj.(*SwitchThread))
}
func (*binaryClassSwitchThread) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SwitchThread{}
	return obj, doDecodeSwitchThread(d, obj)
}
func (*binaryClassSwitchThread) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSwitchThread(d, obj.(*SwitchThread))
}
func (*binaryClassSwitchThread) Skip(d binary.Decoder) error { return doSkipSwitchThread(d) }
func (*binaryClassSwitchThread) Schema() *schema.Class       { return schemaSwitchThread }

var schemaSwitchThread = &schema.Class{
	TypeID:  binaryIDSwitchThread,
	Package: "gles",
	Name:    "SwitchThread",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "ThreadID", Type: &schema.Primitive{Name: "ThreadID", Method: schema.Uint64}},
	},
}

type binaryClassTextureIdˢ struct{}

func (*TextureIdˢ) Class() binary.Class {
	return (*binaryClassTextureIdˢ)(nil)
}
func doEncodeTextureIdˢ(e binary.Encoder, o *TextureIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeTextureIdˢ(d binary.Decoder, o *TextureIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipTextureIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTextureIdˢ) ID() binary.ID      { return binaryIDTextureIdˢ }
func (*binaryClassTextureIdˢ) New() binary.Object { return &TextureIdˢ{} }
func (*binaryClassTextureIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTextureIdˢ(e, obj.(*TextureIdˢ))
}
func (*binaryClassTextureIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TextureIdˢ{}
	return obj, doDecodeTextureIdˢ(d, obj)
}
func (*binaryClassTextureIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTextureIdˢ(d, obj.(*TextureIdˢ))
}
func (*binaryClassTextureIdˢ) Skip(d binary.Decoder) error { return doSkipTextureIdˢ(d) }
func (*binaryClassTextureIdˢ) Schema() *schema.Class       { return schemaTextureIdˢ }

var schemaTextureIdˢ = &schema.Class{
	TypeID:  binaryIDTextureIdˢ,
	Package: "gles",
	Name:    "TextureIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassTransformFeedbackIdˢ struct{}

func (*TransformFeedbackIdˢ) Class() binary.Class {
	return (*binaryClassTransformFeedbackIdˢ)(nil)
}
func doEncodeTransformFeedbackIdˢ(e binary.Encoder, o *TransformFeedbackIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeTransformFeedbackIdˢ(d binary.Decoder, o *TransformFeedbackIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipTransformFeedbackIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTransformFeedbackIdˢ) ID() binary.ID      { return binaryIDTransformFeedbackIdˢ }
func (*binaryClassTransformFeedbackIdˢ) New() binary.Object { return &TransformFeedbackIdˢ{} }
func (*binaryClassTransformFeedbackIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTransformFeedbackIdˢ(e, obj.(*TransformFeedbackIdˢ))
}
func (*binaryClassTransformFeedbackIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TransformFeedbackIdˢ{}
	return obj, doDecodeTransformFeedbackIdˢ(d, obj)
}
func (*binaryClassTransformFeedbackIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTransformFeedbackIdˢ(d, obj.(*TransformFeedbackIdˢ))
}
func (*binaryClassTransformFeedbackIdˢ) Skip(d binary.Decoder) error {
	return doSkipTransformFeedbackIdˢ(d)
}
func (*binaryClassTransformFeedbackIdˢ) Schema() *schema.Class { return schemaTransformFeedbackIdˢ }

var schemaTransformFeedbackIdˢ = &schema.Class{
	TypeID:  binaryIDTransformFeedbackIdˢ,
	Package: "gles",
	Name:    "TransformFeedbackIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU16ˢ struct{}

func (*U16ˢ) Class() binary.Class {
	return (*binaryClassU16ˢ)(nil)
}
func doEncodeU16ˢ(e binary.Encoder, o *U16ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU16ˢ(d binary.Decoder, o *U16ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU16ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU16ˢ) ID() binary.ID      { return binaryIDU16ˢ }
func (*binaryClassU16ˢ) New() binary.Object { return &U16ˢ{} }
func (*binaryClassU16ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU16ˢ(e, obj.(*U16ˢ))
}
func (*binaryClassU16ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U16ˢ{}
	return obj, doDecodeU16ˢ(d, obj)
}
func (*binaryClassU16ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU16ˢ(d, obj.(*U16ˢ))
}
func (*binaryClassU16ˢ) Skip(d binary.Decoder) error { return doSkipU16ˢ(d) }
func (*binaryClassU16ˢ) Schema() *schema.Class       { return schemaU16ˢ }

var schemaU16ˢ = &schema.Class{
	TypeID:  binaryIDU16ˢ,
	Package: "gles",
	Name:    "U16ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU16ᵖ struct{}

func (*U16ᵖ) Class() binary.Class {
	return (*binaryClassU16ᵖ)(nil)
}
func doEncodeU16ᵖ(e binary.Encoder, o *U16ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU16ᵖ(d binary.Decoder, o *U16ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU16ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU16ᵖ) ID() binary.ID      { return binaryIDU16ᵖ }
func (*binaryClassU16ᵖ) New() binary.Object { return &U16ᵖ{} }
func (*binaryClassU16ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU16ᵖ(e, obj.(*U16ᵖ))
}
func (*binaryClassU16ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U16ᵖ{}
	return obj, doDecodeU16ᵖ(d, obj)
}
func (*binaryClassU16ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU16ᵖ(d, obj.(*U16ᵖ))
}
func (*binaryClassU16ᵖ) Skip(d binary.Decoder) error { return doSkipU16ᵖ(d) }
func (*binaryClassU16ᵖ) Schema() *schema.Class       { return schemaU16ᵖ }

var schemaU16ᵖ = &schema.Class{
	TypeID:  binaryIDU16ᵖ,
	Package: "gles",
	Name:    "U16ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassU32ˢ struct{}

func (*U32ˢ) Class() binary.Class {
	return (*binaryClassU32ˢ)(nil)
}
func doEncodeU32ˢ(e binary.Encoder, o *U32ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU32ˢ(d binary.Decoder, o *U32ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU32ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU32ˢ) ID() binary.ID      { return binaryIDU32ˢ }
func (*binaryClassU32ˢ) New() binary.Object { return &U32ˢ{} }
func (*binaryClassU32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU32ˢ(e, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U32ˢ{}
	return obj, doDecodeU32ˢ(d, obj)
}
func (*binaryClassU32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU32ˢ(d, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Skip(d binary.Decoder) error { return doSkipU32ˢ(d) }
func (*binaryClassU32ˢ) Schema() *schema.Class       { return schemaU32ˢ }

var schemaU32ˢ = &schema.Class{
	TypeID:  binaryIDU32ˢ,
	Package: "gles",
	Name:    "U32ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU32ᵖ struct{}

func (*U32ᵖ) Class() binary.Class {
	return (*binaryClassU32ᵖ)(nil)
}
func doEncodeU32ᵖ(e binary.Encoder, o *U32ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU32ᵖ(d binary.Decoder, o *U32ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU32ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU32ᵖ) ID() binary.ID      { return binaryIDU32ᵖ }
func (*binaryClassU32ᵖ) New() binary.Object { return &U32ᵖ{} }
func (*binaryClassU32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU32ᵖ(e, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U32ᵖ{}
	return obj, doDecodeU32ᵖ(d, obj)
}
func (*binaryClassU32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU32ᵖ(d, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Skip(d binary.Decoder) error { return doSkipU32ᵖ(d) }
func (*binaryClassU32ᵖ) Schema() *schema.Class       { return schemaU32ᵖ }

var schemaU32ᵖ = &schema.Class{
	TypeID:  binaryIDU32ᵖ,
	Package: "gles",
	Name:    "U32ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassU64ˢ struct{}

func (*U64ˢ) Class() binary.Class {
	return (*binaryClassU64ˢ)(nil)
}
func doEncodeU64ˢ(e binary.Encoder, o *U64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU64ˢ(d binary.Decoder, o *U64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU64ˢ) ID() binary.ID      { return binaryIDU64ˢ }
func (*binaryClassU64ˢ) New() binary.Object { return &U64ˢ{} }
func (*binaryClassU64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU64ˢ(e, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U64ˢ{}
	return obj, doDecodeU64ˢ(d, obj)
}
func (*binaryClassU64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU64ˢ(d, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Skip(d binary.Decoder) error { return doSkipU64ˢ(d) }
func (*binaryClassU64ˢ) Schema() *schema.Class       { return schemaU64ˢ }

var schemaU64ˢ = &schema.Class{
	TypeID:  binaryIDU64ˢ,
	Package: "gles",
	Name:    "U64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU8ᵖ struct{}

func (*U8ᵖ) Class() binary.Class {
	return (*binaryClassU8ᵖ)(nil)
}
func doEncodeU8ᵖ(e binary.Encoder, o *U8ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU8ᵖ(d binary.Decoder, o *U8ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU8ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU8ᵖ) ID() binary.ID      { return binaryIDU8ᵖ }
func (*binaryClassU8ᵖ) New() binary.Object { return &U8ᵖ{} }
func (*binaryClassU8ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU8ᵖ(e, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U8ᵖ{}
	return obj, doDecodeU8ᵖ(d, obj)
}
func (*binaryClassU8ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU8ᵖ(d, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Skip(d binary.Decoder) error { return doSkipU8ᵖ(d) }
func (*binaryClassU8ᵖ) Schema() *schema.Class       { return schemaU8ᵖ }

var schemaU8ᵖ = &schema.Class{
	TypeID:  binaryIDU8ᵖ,
	Package: "gles",
	Name:    "U8ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec2fː2ᵃ struct{}

func (*Vec2fː2ᵃ) Class() binary.Class {
	return (*binaryClassVec2fː2ᵃ)(nil)
}
func doEncodeVec2fː2ᵃ(e binary.Encoder, o *Vec2fː2ᵃ) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec2fː2ᵃ(d binary.Decoder, o *Vec2fː2ᵃ) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipVec2fː2ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if err := d.SkipValue((*Vec2f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec2fː2ᵃ) ID() binary.ID      { return binaryIDVec2fː2ᵃ }
func (*binaryClassVec2fː2ᵃ) New() binary.Object { return &Vec2fː2ᵃ{} }
func (*binaryClassVec2fː2ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2fː2ᵃ(e, obj.(*Vec2fː2ᵃ))
}
func (*binaryClassVec2fː2ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2fː2ᵃ{}
	return obj, doDecodeVec2fː2ᵃ(d, obj)
}
func (*binaryClassVec2fː2ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2fː2ᵃ(d, obj.(*Vec2fː2ᵃ))
}
func (*binaryClassVec2fː2ᵃ) Skip(d binary.Decoder) error { return doSkipVec2fː2ᵃ(d) }
func (*binaryClassVec2fː2ᵃ) Schema() *schema.Class       { return schemaVec2fː2ᵃ }

var schemaVec2fː2ᵃ = &schema.Class{
	TypeID:  binaryIDVec2fː2ᵃ,
	Package: "gles",
	Name:    "Vec2fː2ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec2f", ID: (*Vec2f)(nil).Class().ID()}, Size: 2}},
	},
}

type binaryClassVec2fˢ struct{}

func (*Vec2fˢ) Class() binary.Class {
	return (*binaryClassVec2fˢ)(nil)
}
func doEncodeVec2fˢ(e binary.Encoder, o *Vec2fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec2fˢ(d binary.Decoder, o *Vec2fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec2fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec2fˢ) ID() binary.ID      { return binaryIDVec2fˢ }
func (*binaryClassVec2fˢ) New() binary.Object { return &Vec2fˢ{} }
func (*binaryClassVec2fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2fˢ(e, obj.(*Vec2fˢ))
}
func (*binaryClassVec2fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2fˢ{}
	return obj, doDecodeVec2fˢ(d, obj)
}
func (*binaryClassVec2fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2fˢ(d, obj.(*Vec2fˢ))
}
func (*binaryClassVec2fˢ) Skip(d binary.Decoder) error { return doSkipVec2fˢ(d) }
func (*binaryClassVec2fˢ) Schema() *schema.Class       { return schemaVec2fˢ }

var schemaVec2fˢ = &schema.Class{
	TypeID:  binaryIDVec2fˢ,
	Package: "gles",
	Name:    "Vec2fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec2fᵖ struct{}

func (*Vec2fᵖ) Class() binary.Class {
	return (*binaryClassVec2fᵖ)(nil)
}
func doEncodeVec2fᵖ(e binary.Encoder, o *Vec2fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec2fᵖ(d binary.Decoder, o *Vec2fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec2fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec2fᵖ) ID() binary.ID      { return binaryIDVec2fᵖ }
func (*binaryClassVec2fᵖ) New() binary.Object { return &Vec2fᵖ{} }
func (*binaryClassVec2fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2fᵖ(e, obj.(*Vec2fᵖ))
}
func (*binaryClassVec2fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2fᵖ{}
	return obj, doDecodeVec2fᵖ(d, obj)
}
func (*binaryClassVec2fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2fᵖ(d, obj.(*Vec2fᵖ))
}
func (*binaryClassVec2fᵖ) Skip(d binary.Decoder) error { return doSkipVec2fᵖ(d) }
func (*binaryClassVec2fᵖ) Schema() *schema.Class       { return schemaVec2fᵖ }

var schemaVec2fᵖ = &schema.Class{
	TypeID:  binaryIDVec2fᵖ,
	Package: "gles",
	Name:    "Vec2fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec2i struct{}

func (*Vec2i) Class() binary.Class {
	return (*binaryClassVec2i)(nil)
}
func doEncodeVec2i(e binary.Encoder, o *Vec2i) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec2i(d binary.Decoder, o *Vec2i) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipVec2i(d binary.Decoder) error {
	for i := uint32(0); i < 2; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec2i) ID() binary.ID      { return binaryIDVec2i }
func (*binaryClassVec2i) New() binary.Object { return &Vec2i{} }
func (*binaryClassVec2i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2i(e, obj.(*Vec2i))
}
func (*binaryClassVec2i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2i{}
	return obj, doDecodeVec2i(d, obj)
}
func (*binaryClassVec2i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2i(d, obj.(*Vec2i))
}
func (*binaryClassVec2i) Skip(d binary.Decoder) error { return doSkipVec2i(d) }
func (*binaryClassVec2i) Schema() *schema.Class       { return schemaVec2i }

var schemaVec2i = &schema.Class{
	TypeID:  binaryIDVec2i,
	Package: "gles",
	Name:    "Vec2i",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 2}},
	},
}

type binaryClassVec2iˢ struct{}

func (*Vec2iˢ) Class() binary.Class {
	return (*binaryClassVec2iˢ)(nil)
}
func doEncodeVec2iˢ(e binary.Encoder, o *Vec2iˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec2iˢ(d binary.Decoder, o *Vec2iˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec2iˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec2iˢ) ID() binary.ID      { return binaryIDVec2iˢ }
func (*binaryClassVec2iˢ) New() binary.Object { return &Vec2iˢ{} }
func (*binaryClassVec2iˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2iˢ(e, obj.(*Vec2iˢ))
}
func (*binaryClassVec2iˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2iˢ{}
	return obj, doDecodeVec2iˢ(d, obj)
}
func (*binaryClassVec2iˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2iˢ(d, obj.(*Vec2iˢ))
}
func (*binaryClassVec2iˢ) Skip(d binary.Decoder) error { return doSkipVec2iˢ(d) }
func (*binaryClassVec2iˢ) Schema() *schema.Class       { return schemaVec2iˢ }

var schemaVec2iˢ = &schema.Class{
	TypeID:  binaryIDVec2iˢ,
	Package: "gles",
	Name:    "Vec2iˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec2iᵖ struct{}

func (*Vec2iᵖ) Class() binary.Class {
	return (*binaryClassVec2iᵖ)(nil)
}
func doEncodeVec2iᵖ(e binary.Encoder, o *Vec2iᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec2iᵖ(d binary.Decoder, o *Vec2iᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec2iᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec2iᵖ) ID() binary.ID      { return binaryIDVec2iᵖ }
func (*binaryClassVec2iᵖ) New() binary.Object { return &Vec2iᵖ{} }
func (*binaryClassVec2iᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec2iᵖ(e, obj.(*Vec2iᵖ))
}
func (*binaryClassVec2iᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec2iᵖ{}
	return obj, doDecodeVec2iᵖ(d, obj)
}
func (*binaryClassVec2iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec2iᵖ(d, obj.(*Vec2iᵖ))
}
func (*binaryClassVec2iᵖ) Skip(d binary.Decoder) error { return doSkipVec2iᵖ(d) }
func (*binaryClassVec2iᵖ) Schema() *schema.Class       { return schemaVec2iᵖ }

var schemaVec2iᵖ = &schema.Class{
	TypeID:  binaryIDVec2iᵖ,
	Package: "gles",
	Name:    "Vec2iᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec3fː3ᵃ struct{}

func (*Vec3fː3ᵃ) Class() binary.Class {
	return (*binaryClassVec3fː3ᵃ)(nil)
}
func doEncodeVec3fː3ᵃ(e binary.Encoder, o *Vec3fː3ᵃ) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec3fː3ᵃ(d binary.Decoder, o *Vec3fː3ᵃ) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipVec3fː3ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if err := d.SkipValue((*Vec3f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec3fː3ᵃ) ID() binary.ID      { return binaryIDVec3fː3ᵃ }
func (*binaryClassVec3fː3ᵃ) New() binary.Object { return &Vec3fː3ᵃ{} }
func (*binaryClassVec3fː3ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3fː3ᵃ(e, obj.(*Vec3fː3ᵃ))
}
func (*binaryClassVec3fː3ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3fː3ᵃ{}
	return obj, doDecodeVec3fː3ᵃ(d, obj)
}
func (*binaryClassVec3fː3ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3fː3ᵃ(d, obj.(*Vec3fː3ᵃ))
}
func (*binaryClassVec3fː3ᵃ) Skip(d binary.Decoder) error { return doSkipVec3fː3ᵃ(d) }
func (*binaryClassVec3fː3ᵃ) Schema() *schema.Class       { return schemaVec3fː3ᵃ }

var schemaVec3fː3ᵃ = &schema.Class{
	TypeID:  binaryIDVec3fː3ᵃ,
	Package: "gles",
	Name:    "Vec3fː3ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec3f", ID: (*Vec3f)(nil).Class().ID()}, Size: 3}},
	},
}

type binaryClassVec3fˢ struct{}

func (*Vec3fˢ) Class() binary.Class {
	return (*binaryClassVec3fˢ)(nil)
}
func doEncodeVec3fˢ(e binary.Encoder, o *Vec3fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec3fˢ(d binary.Decoder, o *Vec3fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec3fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec3fˢ) ID() binary.ID      { return binaryIDVec3fˢ }
func (*binaryClassVec3fˢ) New() binary.Object { return &Vec3fˢ{} }
func (*binaryClassVec3fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3fˢ(e, obj.(*Vec3fˢ))
}
func (*binaryClassVec3fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3fˢ{}
	return obj, doDecodeVec3fˢ(d, obj)
}
func (*binaryClassVec3fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3fˢ(d, obj.(*Vec3fˢ))
}
func (*binaryClassVec3fˢ) Skip(d binary.Decoder) error { return doSkipVec3fˢ(d) }
func (*binaryClassVec3fˢ) Schema() *schema.Class       { return schemaVec3fˢ }

var schemaVec3fˢ = &schema.Class{
	TypeID:  binaryIDVec3fˢ,
	Package: "gles",
	Name:    "Vec3fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec3fᵖ struct{}

func (*Vec3fᵖ) Class() binary.Class {
	return (*binaryClassVec3fᵖ)(nil)
}
func doEncodeVec3fᵖ(e binary.Encoder, o *Vec3fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec3fᵖ(d binary.Decoder, o *Vec3fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec3fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec3fᵖ) ID() binary.ID      { return binaryIDVec3fᵖ }
func (*binaryClassVec3fᵖ) New() binary.Object { return &Vec3fᵖ{} }
func (*binaryClassVec3fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3fᵖ(e, obj.(*Vec3fᵖ))
}
func (*binaryClassVec3fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3fᵖ{}
	return obj, doDecodeVec3fᵖ(d, obj)
}
func (*binaryClassVec3fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3fᵖ(d, obj.(*Vec3fᵖ))
}
func (*binaryClassVec3fᵖ) Skip(d binary.Decoder) error { return doSkipVec3fᵖ(d) }
func (*binaryClassVec3fᵖ) Schema() *schema.Class       { return schemaVec3fᵖ }

var schemaVec3fᵖ = &schema.Class{
	TypeID:  binaryIDVec3fᵖ,
	Package: "gles",
	Name:    "Vec3fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec3i struct{}

func (*Vec3i) Class() binary.Class {
	return (*binaryClassVec3i)(nil)
}
func doEncodeVec3i(e binary.Encoder, o *Vec3i) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec3i(d binary.Decoder, o *Vec3i) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipVec3i(d binary.Decoder) error {
	for i := uint32(0); i < 3; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec3i) ID() binary.ID      { return binaryIDVec3i }
func (*binaryClassVec3i) New() binary.Object { return &Vec3i{} }
func (*binaryClassVec3i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3i(e, obj.(*Vec3i))
}
func (*binaryClassVec3i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3i{}
	return obj, doDecodeVec3i(d, obj)
}
func (*binaryClassVec3i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3i(d, obj.(*Vec3i))
}
func (*binaryClassVec3i) Skip(d binary.Decoder) error { return doSkipVec3i(d) }
func (*binaryClassVec3i) Schema() *schema.Class       { return schemaVec3i }

var schemaVec3i = &schema.Class{
	TypeID:  binaryIDVec3i,
	Package: "gles",
	Name:    "Vec3i",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 3}},
	},
}

type binaryClassVec3iˢ struct{}

func (*Vec3iˢ) Class() binary.Class {
	return (*binaryClassVec3iˢ)(nil)
}
func doEncodeVec3iˢ(e binary.Encoder, o *Vec3iˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec3iˢ(d binary.Decoder, o *Vec3iˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec3iˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec3iˢ) ID() binary.ID      { return binaryIDVec3iˢ }
func (*binaryClassVec3iˢ) New() binary.Object { return &Vec3iˢ{} }
func (*binaryClassVec3iˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3iˢ(e, obj.(*Vec3iˢ))
}
func (*binaryClassVec3iˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3iˢ{}
	return obj, doDecodeVec3iˢ(d, obj)
}
func (*binaryClassVec3iˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3iˢ(d, obj.(*Vec3iˢ))
}
func (*binaryClassVec3iˢ) Skip(d binary.Decoder) error { return doSkipVec3iˢ(d) }
func (*binaryClassVec3iˢ) Schema() *schema.Class       { return schemaVec3iˢ }

var schemaVec3iˢ = &schema.Class{
	TypeID:  binaryIDVec3iˢ,
	Package: "gles",
	Name:    "Vec3iˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec3iᵖ struct{}

func (*Vec3iᵖ) Class() binary.Class {
	return (*binaryClassVec3iᵖ)(nil)
}
func doEncodeVec3iᵖ(e binary.Encoder, o *Vec3iᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec3iᵖ(d binary.Decoder, o *Vec3iᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec3iᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec3iᵖ) ID() binary.ID      { return binaryIDVec3iᵖ }
func (*binaryClassVec3iᵖ) New() binary.Object { return &Vec3iᵖ{} }
func (*binaryClassVec3iᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec3iᵖ(e, obj.(*Vec3iᵖ))
}
func (*binaryClassVec3iᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec3iᵖ{}
	return obj, doDecodeVec3iᵖ(d, obj)
}
func (*binaryClassVec3iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec3iᵖ(d, obj.(*Vec3iᵖ))
}
func (*binaryClassVec3iᵖ) Skip(d binary.Decoder) error { return doSkipVec3iᵖ(d) }
func (*binaryClassVec3iᵖ) Schema() *schema.Class       { return schemaVec3iᵖ }

var schemaVec3iᵖ = &schema.Class{
	TypeID:  binaryIDVec3iᵖ,
	Package: "gles",
	Name:    "Vec3iᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec4fː4ᵃ struct{}

func (*Vec4fː4ᵃ) Class() binary.Class {
	return (*binaryClassVec4fː4ᵃ)(nil)
}
func doEncodeVec4fː4ᵃ(e binary.Encoder, o *Vec4fː4ᵃ) error {
	for i := range o.Elements {
		if err := e.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec4fː4ᵃ(d binary.Decoder, o *Vec4fː4ᵃ) error {
	for i := range o.Elements {
		if err := d.Value(&o.Elements[i]); err != nil {
			return err
		}
	}
	return nil
}
func doSkipVec4fː4ᵃ(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if err := d.SkipValue((*Vec4f)(nil)); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec4fː4ᵃ) ID() binary.ID      { return binaryIDVec4fː4ᵃ }
func (*binaryClassVec4fː4ᵃ) New() binary.Object { return &Vec4fː4ᵃ{} }
func (*binaryClassVec4fː4ᵃ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4fː4ᵃ(e, obj.(*Vec4fː4ᵃ))
}
func (*binaryClassVec4fː4ᵃ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4fː4ᵃ{}
	return obj, doDecodeVec4fː4ᵃ(d, obj)
}
func (*binaryClassVec4fː4ᵃ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4fː4ᵃ(d, obj.(*Vec4fː4ᵃ))
}
func (*binaryClassVec4fː4ᵃ) Skip(d binary.Decoder) error { return doSkipVec4fː4ᵃ(d) }
func (*binaryClassVec4fː4ᵃ) Schema() *schema.Class       { return schemaVec4fː4ᵃ }

var schemaVec4fː4ᵃ = &schema.Class{
	TypeID:  binaryIDVec4fː4ᵃ,
	Package: "gles",
	Name:    "Vec4fː4ᵃ",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Struct{Name: "Vec4f", ID: (*Vec4f)(nil).Class().ID()}, Size: 4}},
	},
}

type binaryClassVec4fˢ struct{}

func (*Vec4fˢ) Class() binary.Class {
	return (*binaryClassVec4fˢ)(nil)
}
func doEncodeVec4fˢ(e binary.Encoder, o *Vec4fˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec4fˢ(d binary.Decoder, o *Vec4fˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec4fˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec4fˢ) ID() binary.ID      { return binaryIDVec4fˢ }
func (*binaryClassVec4fˢ) New() binary.Object { return &Vec4fˢ{} }
func (*binaryClassVec4fˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4fˢ(e, obj.(*Vec4fˢ))
}
func (*binaryClassVec4fˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4fˢ{}
	return obj, doDecodeVec4fˢ(d, obj)
}
func (*binaryClassVec4fˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4fˢ(d, obj.(*Vec4fˢ))
}
func (*binaryClassVec4fˢ) Skip(d binary.Decoder) error { return doSkipVec4fˢ(d) }
func (*binaryClassVec4fˢ) Schema() *schema.Class       { return schemaVec4fˢ }

var schemaVec4fˢ = &schema.Class{
	TypeID:  binaryIDVec4fˢ,
	Package: "gles",
	Name:    "Vec4fˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec4fᵖ struct{}

func (*Vec4fᵖ) Class() binary.Class {
	return (*binaryClassVec4fᵖ)(nil)
}
func doEncodeVec4fᵖ(e binary.Encoder, o *Vec4fᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec4fᵖ(d binary.Decoder, o *Vec4fᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec4fᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec4fᵖ) ID() binary.ID      { return binaryIDVec4fᵖ }
func (*binaryClassVec4fᵖ) New() binary.Object { return &Vec4fᵖ{} }
func (*binaryClassVec4fᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4fᵖ(e, obj.(*Vec4fᵖ))
}
func (*binaryClassVec4fᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4fᵖ{}
	return obj, doDecodeVec4fᵖ(d, obj)
}
func (*binaryClassVec4fᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4fᵖ(d, obj.(*Vec4fᵖ))
}
func (*binaryClassVec4fᵖ) Skip(d binary.Decoder) error { return doSkipVec4fᵖ(d) }
func (*binaryClassVec4fᵖ) Schema() *schema.Class       { return schemaVec4fᵖ }

var schemaVec4fᵖ = &schema.Class{
	TypeID:  binaryIDVec4fᵖ,
	Package: "gles",
	Name:    "Vec4fᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVec4i struct{}

func (*Vec4i) Class() binary.Class {
	return (*binaryClassVec4i)(nil)
}
func doEncodeVec4i(e binary.Encoder, o *Vec4i) error {
	for i := range o.Elements {
		if err := e.Int32(int32(o.Elements[i])); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeVec4i(d binary.Decoder, o *Vec4i) error {
	for i := range o.Elements {
		if obj, err := d.Int32(); err != nil {
			return err
		} else {
			o.Elements[i] = GLint(obj)
		}
	}
	return nil
}
func doSkipVec4i(d binary.Decoder) error {
	for i := uint32(0); i < 4; i++ {
		if _, err := d.Int32(); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassVec4i) ID() binary.ID      { return binaryIDVec4i }
func (*binaryClassVec4i) New() binary.Object { return &Vec4i{} }
func (*binaryClassVec4i) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4i(e, obj.(*Vec4i))
}
func (*binaryClassVec4i) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4i{}
	return obj, doDecodeVec4i(d, obj)
}
func (*binaryClassVec4i) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4i(d, obj.(*Vec4i))
}
func (*binaryClassVec4i) Skip(d binary.Decoder) error { return doSkipVec4i(d) }
func (*binaryClassVec4i) Schema() *schema.Class       { return schemaVec4i }

var schemaVec4i = &schema.Class{
	TypeID:  binaryIDVec4i,
	Package: "gles",
	Name:    "Vec4i",
	Fields: []schema.Field{
		{Declared: "Elements", Type: &schema.Array{Alias: "", ValueType: &schema.Primitive{Name: "GLint", Method: schema.Int32}, Size: 4}},
	},
}

type binaryClassVec4iˢ struct{}

func (*Vec4iˢ) Class() binary.Class {
	return (*binaryClassVec4iˢ)(nil)
}
func doEncodeVec4iˢ(e binary.Encoder, o *Vec4iˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVec4iˢ(d binary.Decoder, o *Vec4iˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVec4iˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec4iˢ) ID() binary.ID      { return binaryIDVec4iˢ }
func (*binaryClassVec4iˢ) New() binary.Object { return &Vec4iˢ{} }
func (*binaryClassVec4iˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4iˢ(e, obj.(*Vec4iˢ))
}
func (*binaryClassVec4iˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4iˢ{}
	return obj, doDecodeVec4iˢ(d, obj)
}
func (*binaryClassVec4iˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4iˢ(d, obj.(*Vec4iˢ))
}
func (*binaryClassVec4iˢ) Skip(d binary.Decoder) error { return doSkipVec4iˢ(d) }
func (*binaryClassVec4iˢ) Schema() *schema.Class       { return schemaVec4iˢ }

var schemaVec4iˢ = &schema.Class{
	TypeID:  binaryIDVec4iˢ,
	Package: "gles",
	Name:    "Vec4iˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVec4iᵖ struct{}

func (*Vec4iᵖ) Class() binary.Class {
	return (*binaryClassVec4iᵖ)(nil)
}
func doEncodeVec4iᵖ(e binary.Encoder, o *Vec4iᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVec4iᵖ(d binary.Decoder, o *Vec4iᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVec4iᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVec4iᵖ) ID() binary.ID      { return binaryIDVec4iᵖ }
func (*binaryClassVec4iᵖ) New() binary.Object { return &Vec4iᵖ{} }
func (*binaryClassVec4iᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVec4iᵖ(e, obj.(*Vec4iᵖ))
}
func (*binaryClassVec4iᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Vec4iᵖ{}
	return obj, doDecodeVec4iᵖ(d, obj)
}
func (*binaryClassVec4iᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVec4iᵖ(d, obj.(*Vec4iᵖ))
}
func (*binaryClassVec4iᵖ) Skip(d binary.Decoder) error { return doSkipVec4iᵖ(d) }
func (*binaryClassVec4iᵖ) Schema() *schema.Class       { return schemaVec4iᵖ }

var schemaVec4iᵖ = &schema.Class{
	TypeID:  binaryIDVec4iᵖ,
	Package: "gles",
	Name:    "Vec4iᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassVertexArrayIdˢ struct{}

func (*VertexArrayIdˢ) Class() binary.Class {
	return (*binaryClassVertexArrayIdˢ)(nil)
}
func doEncodeVertexArrayIdˢ(e binary.Encoder, o *VertexArrayIdˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVertexArrayIdˢ(d binary.Decoder, o *VertexArrayIdˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVertexArrayIdˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVertexArrayIdˢ) ID() binary.ID      { return binaryIDVertexArrayIdˢ }
func (*binaryClassVertexArrayIdˢ) New() binary.Object { return &VertexArrayIdˢ{} }
func (*binaryClassVertexArrayIdˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVertexArrayIdˢ(e, obj.(*VertexArrayIdˢ))
}
func (*binaryClassVertexArrayIdˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &VertexArrayIdˢ{}
	return obj, doDecodeVertexArrayIdˢ(d, obj)
}
func (*binaryClassVertexArrayIdˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVertexArrayIdˢ(d, obj.(*VertexArrayIdˢ))
}
func (*binaryClassVertexArrayIdˢ) Skip(d binary.Decoder) error { return doSkipVertexArrayIdˢ(d) }
func (*binaryClassVertexArrayIdˢ) Schema() *schema.Class       { return schemaVertexArrayIdˢ }

var schemaVertexArrayIdˢ = &schema.Class{
	TypeID:  binaryIDVertexArrayIdˢ,
	Package: "gles",
	Name:    "VertexArrayIdˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVoidˢ struct{}

func (*Voidˢ) Class() binary.Class {
	return (*binaryClassVoidˢ)(nil)
}
func doEncodeVoidˢ(e binary.Encoder, o *Voidˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidˢ(d binary.Decoder, o *Voidˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVoidˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidˢ) ID() binary.ID      { return binaryIDVoidˢ }
func (*binaryClassVoidˢ) New() binary.Object { return &Voidˢ{} }
func (*binaryClassVoidˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidˢ(e, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidˢ{}
	return obj, doDecodeVoidˢ(d, obj)
}
func (*binaryClassVoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidˢ(d, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Skip(d binary.Decoder) error { return doSkipVoidˢ(d) }
func (*binaryClassVoidˢ) Schema() *schema.Class       { return schemaVoidˢ }

var schemaVoidˢ = &schema.Class{
	TypeID:  binaryIDVoidˢ,
	Package: "gles",
	Name:    "Voidˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVoidᵖˢ struct{}

func (*Voidᵖˢ) Class() binary.Class {
	return (*binaryClassVoidᵖˢ)(nil)
}
func doEncodeVoidᵖˢ(e binary.Encoder, o *Voidᵖˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᵖˢ(d binary.Decoder, o *Voidᵖˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᵖˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᵖˢ) ID() binary.ID      { return binaryIDVoidᵖˢ }
func (*binaryClassVoidᵖˢ) New() binary.Object { return &Voidᵖˢ{} }
func (*binaryClassVoidᵖˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᵖˢ(e, obj.(*Voidᵖˢ))
}
func (*binaryClassVoidᵖˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᵖˢ{}
	return obj, doDecodeVoidᵖˢ(d, obj)
}
func (*binaryClassVoidᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᵖˢ(d, obj.(*Voidᵖˢ))
}
func (*binaryClassVoidᵖˢ) Skip(d binary.Decoder) error { return doSkipVoidᵖˢ(d) }
func (*binaryClassVoidᵖˢ) Schema() *schema.Class       { return schemaVoidᵖˢ }

var schemaVoidᵖˢ = &schema.Class{
	TypeID:  binaryIDVoidᵖˢ,
	Package: "gles",
	Name:    "Voidᵖˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVoidᶜᵖˢ struct{}

func (*Voidᶜᵖˢ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖˢ)(nil)
}
func doEncodeVoidᶜᵖˢ(e binary.Encoder, o *Voidᶜᵖˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᶜᵖˢ(d binary.Decoder, o *Voidᶜᵖˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᶜᵖˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᶜᵖˢ) ID() binary.ID      { return binaryIDVoidᶜᵖˢ }
func (*binaryClassVoidᶜᵖˢ) New() binary.Object { return &Voidᶜᵖˢ{} }
func (*binaryClassVoidᶜᵖˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᶜᵖˢ(e, obj.(*Voidᶜᵖˢ))
}
func (*binaryClassVoidᶜᵖˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᶜᵖˢ{}
	return obj, doDecodeVoidᶜᵖˢ(d, obj)
}
func (*binaryClassVoidᶜᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᶜᵖˢ(d, obj.(*Voidᶜᵖˢ))
}
func (*binaryClassVoidᶜᵖˢ) Skip(d binary.Decoder) error { return doSkipVoidᶜᵖˢ(d) }
func (*binaryClassVoidᶜᵖˢ) Schema() *schema.Class       { return schemaVoidᶜᵖˢ }

var schemaVoidᶜᵖˢ = &schema.Class{
	TypeID:  binaryIDVoidᶜᵖˢ,
	Package: "gles",
	Name:    "Voidᶜᵖˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVoidᶜᵖᵖ struct{}

func (*Voidᶜᵖᵖ) Class() binary.Class {
	return (*binaryClassVoidᶜᵖᵖ)(nil)
}
func doEncodeVoidᶜᵖᵖ(e binary.Encoder, o *Voidᶜᵖᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᶜᵖᵖ(d binary.Decoder, o *Voidᶜᵖᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᶜᵖᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᶜᵖᵖ) ID() binary.ID      { return binaryIDVoidᶜᵖᵖ }
func (*binaryClassVoidᶜᵖᵖ) New() binary.Object { return &Voidᶜᵖᵖ{} }
func (*binaryClassVoidᶜᵖᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᶜᵖᵖ(e, obj.(*Voidᶜᵖᵖ))
}
func (*binaryClassVoidᶜᵖᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᶜᵖᵖ{}
	return obj, doDecodeVoidᶜᵖᵖ(d, obj)
}
func (*binaryClassVoidᶜᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᶜᵖᵖ(d, obj.(*Voidᶜᵖᵖ))
}
func (*binaryClassVoidᶜᵖᵖ) Skip(d binary.Decoder) error { return doSkipVoidᶜᵖᵖ(d) }
func (*binaryClassVoidᶜᵖᵖ) Schema() *schema.Class       { return schemaVoidᶜᵖᵖ }

var schemaVoidᶜᵖᵖ = &schema.Class{
	TypeID:  binaryIDVoidᶜᵖᵖ,
	Package: "gles",
	Name:    "Voidᶜᵖᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassWglCreateContext struct{}

func (*WglCreateContext) Class() binary.Class {
	return (*binaryClassWglCreateContext)(nil)
}
func doEncodeWglCreateContext(e binary.Encoder, o *WglCreateContext) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Hdc); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeWglCreateContext(d binary.Decoder, o *WglCreateContext) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Hdc); err != nil {
		return err
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipWglCreateContext(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HDC)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HGLRC)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassWglCreateContext) ID() binary.ID      { return binaryIDWglCreateContext }
func (*binaryClassWglCreateContext) New() binary.Object { return &WglCreateContext{} }
func (*binaryClassWglCreateContext) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeWglCreateContext(e, obj.(*WglCreateContext))
}
func (*binaryClassWglCreateContext) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &WglCreateContext{}
	return obj, doDecodeWglCreateContext(d, obj)
}
func (*binaryClassWglCreateContext) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeWglCreateContext(d, obj.(*WglCreateContext))
}
func (*binaryClassWglCreateContext) Skip(d binary.Decoder) error { return doSkipWglCreateContext(d) }
func (*binaryClassWglCreateContext) Schema() *schema.Class       { return schemaWglCreateContext }

var schemaWglCreateContext = &schema.Class{
	TypeID:  binaryIDWglCreateContext,
	Package: "gles",
	Name:    "WglCreateContext",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Hdc", Type: &schema.Struct{Name: "HDC", ID: (*HDC)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Struct{Name: "HGLRC", ID: (*HGLRC)(nil).Class().ID()}},
	},
}

type binaryClassWglCreateContextAttribsARB struct{}

func (*WglCreateContextAttribsARB) Class() binary.Class {
	return (*binaryClassWglCreateContextAttribsARB)(nil)
}
func doEncodeWglCreateContextAttribsARB(e binary.Encoder, o *WglCreateContextAttribsARB) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Hdc); err != nil {
		return err
	}
	if err := e.Value(&o.HShareContext); err != nil {
		return err
	}
	if err := e.Value(&o.AttribList); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeWglCreateContextAttribsARB(d binary.Decoder, o *WglCreateContextAttribsARB) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Hdc); err != nil {
		return err
	}
	if err := d.Value(&o.HShareContext); err != nil {
		return err
	}
	if err := d.Value(&o.AttribList); err != nil {
		return err
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipWglCreateContextAttribsARB(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HDC)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HGLRC)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HGLRC)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassWglCreateContextAttribsARB) ID() binary.ID {
	return binaryIDWglCreateContextAttribsARB
}
func (*binaryClassWglCreateContextAttribsARB) New() binary.Object {
	return &WglCreateContextAttribsARB{}
}
func (*binaryClassWglCreateContextAttribsARB) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeWglCreateContextAttribsARB(e, obj.(*WglCreateContextAttribsARB))
}
func (*binaryClassWglCreateContextAttribsARB) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &WglCreateContextAttribsARB{}
	return obj, doDecodeWglCreateContextAttribsARB(d, obj)
}
func (*binaryClassWglCreateContextAttribsARB) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeWglCreateContextAttribsARB(d, obj.(*WglCreateContextAttribsARB))
}
func (*binaryClassWglCreateContextAttribsARB) Skip(d binary.Decoder) error {
	return doSkipWglCreateContextAttribsARB(d)
}
func (*binaryClassWglCreateContextAttribsARB) Schema() *schema.Class {
	return schemaWglCreateContextAttribsARB
}

var schemaWglCreateContextAttribsARB = &schema.Class{
	TypeID:  binaryIDWglCreateContextAttribsARB,
	Package: "gles",
	Name:    "WglCreateContextAttribsARB",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Hdc", Type: &schema.Struct{Name: "HDC", ID: (*HDC)(nil).Class().ID()}},
		{Declared: "HShareContext", Type: &schema.Struct{Name: "HGLRC", ID: (*HGLRC)(nil).Class().ID()}},
		{Declared: "AttribList", Type: &schema.Struct{Name: "Intᵖ", ID: (*Intᵖ)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Struct{Name: "HGLRC", ID: (*HGLRC)(nil).Class().ID()}},
	},
}

type binaryClassWglMakeCurrent struct{}

func (*WglMakeCurrent) Class() binary.Class {
	return (*binaryClassWglMakeCurrent)(nil)
}
func doEncodeWglMakeCurrent(e binary.Encoder, o *WglMakeCurrent) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Hdc); err != nil {
		return err
	}
	if err := e.Value(&o.Hglrc); err != nil {
		return err
	}
	if err := e.Int64(int64(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeWglMakeCurrent(d binary.Decoder, o *WglMakeCurrent) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Hdc); err != nil {
		return err
	}
	if err := d.Value(&o.Hglrc); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = BOOL(obj)
	}
	return nil
}
func doSkipWglMakeCurrent(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HDC)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HGLRC)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassWglMakeCurrent) ID() binary.ID      { return binaryIDWglMakeCurrent }
func (*binaryClassWglMakeCurrent) New() binary.Object { return &WglMakeCurrent{} }
func (*binaryClassWglMakeCurrent) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeWglMakeCurrent(e, obj.(*WglMakeCurrent))
}
func (*binaryClassWglMakeCurrent) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &WglMakeCurrent{}
	return obj, doDecodeWglMakeCurrent(d, obj)
}
func (*binaryClassWglMakeCurrent) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeWglMakeCurrent(d, obj.(*WglMakeCurrent))
}
func (*binaryClassWglMakeCurrent) Skip(d binary.Decoder) error { return doSkipWglMakeCurrent(d) }
func (*binaryClassWglMakeCurrent) Schema() *schema.Class       { return schemaWglMakeCurrent }

var schemaWglMakeCurrent = &schema.Class{
	TypeID:  binaryIDWglMakeCurrent,
	Package: "gles",
	Name:    "WglMakeCurrent",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Hdc", Type: &schema.Struct{Name: "HDC", ID: (*HDC)(nil).Class().ID()}},
		{Declared: "Hglrc", Type: &schema.Struct{Name: "HGLRC", ID: (*HGLRC)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "BOOL", Method: schema.Int64}},
	},
}

type binaryClassWglSwapBuffers struct{}

func (*WglSwapBuffers) Class() binary.Class {
	return (*binaryClassWglSwapBuffers)(nil)
}
func doEncodeWglSwapBuffers(e binary.Encoder, o *WglSwapBuffers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Hdc); err != nil {
		return err
	}
	return nil
}
func doDecodeWglSwapBuffers(d binary.Decoder, o *WglSwapBuffers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Hdc); err != nil {
		return err
	}
	return nil
}
func doSkipWglSwapBuffers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*HDC)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassWglSwapBuffers) ID() binary.ID      { return binaryIDWglSwapBuffers }
func (*binaryClassWglSwapBuffers) New() binary.Object { return &WglSwapBuffers{} }
func (*binaryClassWglSwapBuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeWglSwapBuffers(e, obj.(*WglSwapBuffers))
}
func (*binaryClassWglSwapBuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &WglSwapBuffers{}
	return obj, doDecodeWglSwapBuffers(d, obj)
}
func (*binaryClassWglSwapBuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeWglSwapBuffers(d, obj.(*WglSwapBuffers))
}
func (*binaryClassWglSwapBuffers) Skip(d binary.Decoder) error { return doSkipWglSwapBuffers(d) }
func (*binaryClassWglSwapBuffers) Schema() *schema.Class       { return schemaWglSwapBuffers }

var schemaWglSwapBuffers = &schema.Class{
	TypeID:  binaryIDWglSwapBuffers,
	Package: "gles",
	Name:    "WglSwapBuffers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Hdc", Type: &schema.Struct{Name: "HDC", ID: (*HDC)(nil).Class().ID()}},
	},
}

type binaryClassgenerate_types struct{}

func (*generate_types) Class() binary.Class {
	return (*binaryClassgenerate_types)(nil)
}
func doEncodegenerate_types(e binary.Encoder, o *generate_types) error {
	if err := e.Value(&o.U16_slice); err != nil {
		return err
	}
	if err := e.Value(&o.U32_slice); err != nil {
		return err
	}
	return nil
}
func doDecodegenerate_types(d binary.Decoder, o *generate_types) error {
	if err := d.Value(&o.U16_slice); err != nil {
		return err
	}
	if err := d.Value(&o.U32_slice); err != nil {
		return err
	}
	return nil
}
func doSkipgenerate_types(d binary.Decoder) error {
	if err := d.SkipValue((*U16ˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U32ˢ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassgenerate_types) ID() binary.ID      { return binaryIDgenerate_types }
func (*binaryClassgenerate_types) New() binary.Object { return &generate_types{} }
func (*binaryClassgenerate_types) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodegenerate_types(e, obj.(*generate_types))
}
func (*binaryClassgenerate_types) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &generate_types{}
	return obj, doDecodegenerate_types(d, obj)
}
func (*binaryClassgenerate_types) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodegenerate_types(d, obj.(*generate_types))
}
func (*binaryClassgenerate_types) Skip(d binary.Decoder) error { return doSkipgenerate_types(d) }
func (*binaryClassgenerate_types) Schema() *schema.Class       { return schemagenerate_types }

var schemagenerate_types = &schema.Class{
	TypeID:  binaryIDgenerate_types,
	Package: "gles",
	Name:    "generate_types",
	Fields: []schema.Field{
		{Declared: "U16_slice", Type: &schema.Struct{Name: "U16ˢ", ID: (*U16ˢ)(nil).Class().ID()}},
		{Declared: "U32_slice", Type: &schema.Struct{Name: "U32ˢ", ID: (*U32ˢ)(nil).Class().ID()}},
	},
}

var ConstantValues schema.Constants

var _ExtensionId_map = map[ExtensionId]string{}

func init() {
	_ExtensionId_map[1] = "GL_AMD_performance_monitor"
	_ExtensionId_map[2] = "GL_ANGLE_framebuffer_blit"
	_ExtensionId_map[3] = "GL_ANGLE_framebuffer_multisample"
	_ExtensionId_map[4] = "GL_ANGLE_instanced_arrays"
	_ExtensionId_map[5] = "GL_ANGLE_translated_shader_source"
	_ExtensionId_map[6] = "GL_APPLE_copy_texture_levels"
	_ExtensionId_map[7] = "GL_APPLE_framebuffer_multisample"
	_ExtensionId_map[8] = "GL_APPLE_sync"
	_ExtensionId_map[9] = "GL_EXT_base_instance"
	_ExtensionId_map[10] = "GL_EXT_buffer_storage"
	_ExtensionId_map[11] = "GL_EXT_copy_image"
	_ExtensionId_map[12] = "GL_EXT_debug_label"
	_ExtensionId_map[13] = "GL_EXT_debug_marker"
	_ExtensionId_map[14] = "GL_EXT_discard_framebuffer"
	_ExtensionId_map[15] = "GL_EXT_disjoint_timer_query"
	_ExtensionId_map[16] = "GL_EXT_draw_buffers"
	_ExtensionId_map[17] = "GL_EXT_draw_buffers_indexed"
	_ExtensionId_map[18] = "GL_EXT_draw_elements_base_vertex"
	_ExtensionId_map[19] = "GL_EXT_draw_instanced"
	_ExtensionId_map[20] = "GL_EXT_geometry_shader"
	_ExtensionId_map[21] = "GL_EXT_instanced_arrays"
	_ExtensionId_map[22] = "GL_EXT_map_buffer_range"
	_ExtensionId_map[23] = "GL_EXT_multi_draw_arrays"
	_ExtensionId_map[24] = "GL_EXT_multi_draw_indirect"
	_ExtensionId_map[25] = "GL_EXT_multisampled_render_to_texture"
	_ExtensionId_map[26] = "GL_EXT_multiview_draw_buffers"
	_ExtensionId_map[27] = "GL_EXT_occlusion_query_boolean"
	_ExtensionId_map[28] = "GL_EXT_primitive_bounding_box"
	_ExtensionId_map[29] = "GL_EXT_raster_multisample"
	_ExtensionId_map[30] = "GL_EXT_robustness"
	_ExtensionId_map[31] = "GL_EXT_separate_shader_objects"
	_ExtensionId_map[32] = "GL_EXT_sparse_texture"
	_ExtensionId_map[33] = "GL_EXT_tessellation_shader"
	_ExtensionId_map[34] = "GL_EXT_texture_border_clamp"
	_ExtensionId_map[35] = "GL_EXT_texture_buffer"
	_ExtensionId_map[36] = "GL_EXT_texture_filter_minmax"
	_ExtensionId_map[37] = "GL_EXT_texture_storage"
	_ExtensionId_map[38] = "GL_EXT_texture_view"
	_ExtensionId_map[39] = "GL_IMG_multisampled_render_to_texture"
	_ExtensionId_map[40] = "GL_INTEL_performance_query"
	_ExtensionId_map[41] = "GL_KHR_blend_equation_advanced"
	_ExtensionId_map[42] = "GL_KHR_debug"
	_ExtensionId_map[43] = "GL_KHR_robustness"
	_ExtensionId_map[44] = "GL_NV_bindless_texture"
	_ExtensionId_map[45] = "GL_NV_blend_equation_advanced"
	_ExtensionId_map[46] = "GL_NV_conditional_render"
	_ExtensionId_map[47] = "GL_NV_conservative_raster"
	_ExtensionId_map[48] = "GL_NV_copy_buffer"
	_ExtensionId_map[49] = "GL_NV_coverage_sample"
	_ExtensionId_map[50] = "GL_NV_draw_buffers"
	_ExtensionId_map[51] = "GL_NV_draw_instanced"
	_ExtensionId_map[52] = "GL_NV_fence"
	_ExtensionId_map[53] = "GL_NV_fragment_coverage_to_color"
	_ExtensionId_map[54] = "GL_NV_framebuffer_blit"
	_ExtensionId_map[55] = "GL_NV_framebuffer_mixed_samples"
	_ExtensionId_map[56] = "GL_NV_framebuffer_multisample"
	_ExtensionId_map[57] = "GL_NV_instanced_arrays"
	_ExtensionId_map[58] = "GL_NV_internalformat_sample_query"
	_ExtensionId_map[59] = "GL_NV_non_square_matrices"
	_ExtensionId_map[60] = "GL_NV_path_rendering"
	_ExtensionId_map[61] = "GL_NV_polygon_mode"
	_ExtensionId_map[62] = "GL_NV_read_buffer"
	_ExtensionId_map[63] = "GL_NV_sample_locations"
	_ExtensionId_map[64] = "GL_NV_viewport_array"
	_ExtensionId_map[65] = "GL_OES_copy_image"
	_ExtensionId_map[66] = "GL_OES_draw_buffers_indexed"
	_ExtensionId_map[67] = "GL_OES_draw_elements_base_vertex"
	_ExtensionId_map[68] = "GL_OES_EGL_image"
	_ExtensionId_map[69] = "GL_OES_geometry_shader"
	_ExtensionId_map[70] = "GL_OES_get_program_binary"
	_ExtensionId_map[71] = "GL_OES_mapbuffer"
	_ExtensionId_map[72] = "GL_OES_primitive_bounding_box"
	_ExtensionId_map[73] = "GL_OES_sample_shading"
	_ExtensionId_map[74] = "GL_OES_tessellation_shader"
	_ExtensionId_map[75] = "GL_OES_texture_3D"
	_ExtensionId_map[76] = "GL_OES_texture_border_clamp"
	_ExtensionId_map[77] = "GL_OES_texture_buffer"
	_ExtensionId_map[78] = "GL_OES_texture_storage_multisample_2d_array"
	_ExtensionId_map[79] = "GL_OES_texture_view"
	_ExtensionId_map[80] = "GL_OES_vertex_array_object"
	_ExtensionId_map[81] = "GL_OVR_multiview"
	_ExtensionId_map[82] = "GL_QCOM_alpha_test"
	_ExtensionId_map[83] = "GL_QCOM_driver_control"
	_ExtensionId_map[84] = "GL_QCOM_extended_get"
	_ExtensionId_map[85] = "GL_QCOM_extended_get2"
	_ExtensionId_map[86] = "GL_QCOM_tiled_rendering"
	_ExtensionId_map[87] = "GL_AMD_compressed_ATC_texture"
	_ExtensionId_map[88] = "GL_OES_texture_half_float"
	_ExtensionId_map[89] = "GL_OES_vertex_half_float"

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "ExtensionId", Method: schema.Uint32},
		Entries: []schema.Constant{
			{Name: "GL_AMD_performance_monitor", Value: uint32(1)},
			{Name: "GL_ANGLE_framebuffer_blit", Value: uint32(2)},
			{Name: "GL_ANGLE_framebuffer_multisample", Value: uint32(3)},
			{Name: "GL_ANGLE_instanced_arrays", Value: uint32(4)},
			{Name: "GL_ANGLE_translated_shader_source", Value: uint32(5)},
			{Name: "GL_APPLE_copy_texture_levels", Value: uint32(6)},
			{Name: "GL_APPLE_framebuffer_multisample", Value: uint32(7)},
			{Name: "GL_APPLE_sync", Value: uint32(8)},
			{Name: "GL_EXT_base_instance", Value: uint32(9)},
			{Name: "GL_EXT_buffer_storage", Value: uint32(10)},
			{Name: "GL_EXT_copy_image", Value: uint32(11)},
			{Name: "GL_EXT_debug_label", Value: uint32(12)},
			{Name: "GL_EXT_debug_marker", Value: uint32(13)},
			{Name: "GL_EXT_discard_framebuffer", Value: uint32(14)},
			{Name: "GL_EXT_disjoint_timer_query", Value: uint32(15)},
			{Name: "GL_EXT_draw_buffers", Value: uint32(16)},
			{Name: "GL_EXT_draw_buffers_indexed", Value: uint32(17)},
			{Name: "GL_EXT_draw_elements_base_vertex", Value: uint32(18)},
			{Name: "GL_EXT_draw_instanced", Value: uint32(19)},
			{Name: "GL_EXT_geometry_shader", Value: uint32(20)},
			{Name: "GL_EXT_instanced_arrays", Value: uint32(21)},
			{Name: "GL_EXT_map_buffer_range", Value: uint32(22)},
			{Name: "GL_EXT_multi_draw_arrays", Value: uint32(23)},
			{Name: "GL_EXT_multi_draw_indirect", Value: uint32(24)},
			{Name: "GL_EXT_multisampled_render_to_texture", Value: uint32(25)},
			{Name: "GL_EXT_multiview_draw_buffers", Value: uint32(26)},
			{Name: "GL_EXT_occlusion_query_boolean", Value: uint32(27)},
			{Name: "GL_EXT_primitive_bounding_box", Value: uint32(28)},
			{Name: "GL_EXT_raster_multisample", Value: uint32(29)},
			{Name: "GL_EXT_robustness", Value: uint32(30)},
			{Name: "GL_EXT_separate_shader_objects", Value: uint32(31)},
			{Name: "GL_EXT_sparse_texture", Value: uint32(32)},
			{Name: "GL_EXT_tessellation_shader", Value: uint32(33)},
			{Name: "GL_EXT_texture_border_clamp", Value: uint32(34)},
			{Name: "GL_EXT_texture_buffer", Value: uint32(35)},
			{Name: "GL_EXT_texture_filter_minmax", Value: uint32(36)},
			{Name: "GL_EXT_texture_storage", Value: uint32(37)},
			{Name: "GL_EXT_texture_view", Value: uint32(38)},
			{Name: "GL_IMG_multisampled_render_to_texture", Value: uint32(39)},
			{Name: "GL_INTEL_performance_query", Value: uint32(40)},
			{Name: "GL_KHR_blend_equation_advanced", Value: uint32(41)},
			{Name: "GL_KHR_debug", Value: uint32(42)},
			{Name: "GL_KHR_robustness", Value: uint32(43)},
			{Name: "GL_NV_bindless_texture", Value: uint32(44)},
			{Name: "GL_NV_blend_equation_advanced", Value: uint32(45)},
			{Name: "GL_NV_conditional_render", Value: uint32(46)},
			{Name: "GL_NV_conservative_raster", Value: uint32(47)},
			{Name: "GL_NV_copy_buffer", Value: uint32(48)},
			{Name: "GL_NV_coverage_sample", Value: uint32(49)},
			{Name: "GL_NV_draw_buffers", Value: uint32(50)},
			{Name: "GL_NV_draw_instanced", Value: uint32(51)},
			{Name: "GL_NV_fence", Value: uint32(52)},
			{Name: "GL_NV_fragment_coverage_to_color", Value: uint32(53)},
			{Name: "GL_NV_framebuffer_blit", Value: uint32(54)},
			{Name: "GL_NV_framebuffer_mixed_samples", Value: uint32(55)},
			{Name: "GL_NV_framebuffer_multisample", Value: uint32(56)},
			{Name: "GL_NV_instanced_arrays", Value: uint32(57)},
			{Name: "GL_NV_internalformat_sample_query", Value: uint32(58)},
			{Name: "GL_NV_non_square_matrices", Value: uint32(59)},
			{Name: "GL_NV_path_rendering", Value: uint32(60)},
			{Name: "GL_NV_polygon_mode", Value: uint32(61)},
			{Name: "GL_NV_read_buffer", Value: uint32(62)},
			{Name: "GL_NV_sample_locations", Value: uint32(63)},
			{Name: "GL_NV_viewport_array", Value: uint32(64)},
			{Name: "GL_OES_copy_image", Value: uint32(65)},
			{Name: "GL_OES_draw_buffers_indexed", Value: uint32(66)},
			{Name: "GL_OES_draw_elements_base_vertex", Value: uint32(67)},
			{Name: "GL_OES_EGL_image", Value: uint32(68)},
			{Name: "GL_OES_geometry_shader", Value: uint32(69)},
			{Name: "GL_OES_get_program_binary", Value: uint32(70)},
			{Name: "GL_OES_mapbuffer", Value: uint32(71)},
			{Name: "GL_OES_primitive_bounding_box", Value: uint32(72)},
			{Name: "GL_OES_sample_shading", Value: uint32(73)},
			{Name: "GL_OES_tessellation_shader", Value: uint32(74)},
			{Name: "GL_OES_texture_3D", Value: uint32(75)},
			{Name: "GL_OES_texture_border_clamp", Value: uint32(76)},
			{Name: "GL_OES_texture_buffer", Value: uint32(77)},
			{Name: "GL_OES_texture_storage_multisample_2d_array", Value: uint32(78)},
			{Name: "GL_OES_texture_view", Value: uint32(79)},
			{Name: "GL_OES_vertex_array_object", Value: uint32(80)},
			{Name: "GL_OVR_multiview", Value: uint32(81)},
			{Name: "GL_QCOM_alpha_test", Value: uint32(82)},
			{Name: "GL_QCOM_driver_control", Value: uint32(83)},
			{Name: "GL_QCOM_extended_get", Value: uint32(84)},
			{Name: "GL_QCOM_extended_get2", Value: uint32(85)},
			{Name: "GL_QCOM_tiled_rendering", Value: uint32(86)},
			{Name: "GL_AMD_compressed_ATC_texture", Value: uint32(87)},
			{Name: "GL_OES_texture_half_float", Value: uint32(88)},
			{Name: "GL_OES_vertex_half_float", Value: uint32(89)},
		},
	})
}

func (v ExtensionId) String() string {
	if s, ok := _ExtensionId_map[v]; ok {
		return s
	}
	return fmt.Sprintf("ExtensionId(%d)", v)
}

func (v *ExtensionId) Parse(s string) error {
	for k, t := range _ExtensionId_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in ExtensionId", s)
}

var _GLbitfield_map = map[GLbitfield]string{}

func init() {
	_GLbitfield_map[0] = "GL_PERFQUERY_SINGLE_CONTEXT_INTEL"
	_GLbitfield_map[1] = "GL_RED_BIT_ATI"
	_GLbitfield_map[1] = "GL_TRACE_OPERATIONS_BIT_MESA"
	_GLbitfield_map[1] = "GL_2X_BIT_ATI"
	_GLbitfield_map[1] = "GL_COLOR_BUFFER_BIT0_QCOM"
	_GLbitfield_map[1] = "GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT"
	_GLbitfield_map[1] = "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT"
	_GLbitfield_map[1] = "GL_CURRENT_BIT"
	_GLbitfield_map[1] = "GL_VERTEX_SHADER_BIT"
	_GLbitfield_map[1] = "GL_BOLD_BIT_NV"
	_GLbitfield_map[1] = "GL_MAP_READ_BIT_EXT"
	_GLbitfield_map[1] = "GL_SYNC_FLUSH_COMMANDS_BIT"
	_GLbitfield_map[1] = "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE"
	_GLbitfield_map[1] = "GL_GLYPH_WIDTH_BIT_NV"
	_GLbitfield_map[1] = "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT"
	_GLbitfield_map[1] = "GL_MAP_READ_BIT"
	_GLbitfield_map[1] = "GL_CONTEXT_CORE_PROFILE_BIT"
	_GLbitfield_map[1] = "GL_TEXTURE_DEFORMATION_BIT_SGIX"
	_GLbitfield_map[1] = "GL_CLIENT_PIXEL_STORE_BIT"
	_GLbitfield_map[1] = "GL_PERFQUERY_GLOBAL_CONTEXT_INTEL"
	_GLbitfield_map[1] = "GL_TEXTURE_STORAGE_SPARSE_BIT_AMD"
	_GLbitfield_map[1] = "GL_VERTEX_SHADER_BIT_EXT"
	_GLbitfield_map[2] = "GL_CONTEXT_FLAG_DEBUG_BIT_KHR"
	_GLbitfield_map[2] = "GL_ELEMENT_ARRAY_BARRIER_BIT_EXT"
	_GLbitfield_map[2] = "GL_MAP_WRITE_BIT_EXT"
	_GLbitfield_map[2] = "GL_POINT_BIT"
	_GLbitfield_map[2] = "GL_ELEMENT_ARRAY_BARRIER_BIT"
	_GLbitfield_map[2] = "GL_4X_BIT_ATI"
	_GLbitfield_map[2] = "GL_MAP_WRITE_BIT"
	_GLbitfield_map[2] = "GL_TRACE_PRIMITIVES_BIT_MESA"
	_GLbitfield_map[2] = "GL_ITALIC_BIT_NV"
	_GLbitfield_map[2] = "GL_CLIENT_VERTEX_ARRAY_BIT"
	_GLbitfield_map[2] = "GL_COLOR_BUFFER_BIT1_QCOM"
	_GLbitfield_map[2] = "GL_GREEN_BIT_ATI"
	_GLbitfield_map[2] = "GL_GLYPH_HEIGHT_BIT_NV"
	_GLbitfield_map[2] = "GL_GEOMETRY_DEFORMATION_BIT_SGIX"
	_GLbitfield_map[2] = "GL_FRAGMENT_SHADER_BIT_EXT"
	_GLbitfield_map[2] = "GL_FRAGMENT_SHADER_BIT"
	_GLbitfield_map[2] = "GL_COMP_BIT_ATI"
	_GLbitfield_map[2] = "GL_CONTEXT_COMPATIBILITY_PROFILE_BIT"
	_GLbitfield_map[2] = "GL_CONTEXT_FLAG_DEBUG_BIT"
	_GLbitfield_map[4] = "GL_LINE_BIT"
	_GLbitfield_map[4] = "GL_NEGATE_BIT_ATI"
	_GLbitfield_map[4] = "GL_8X_BIT_ATI"
	_GLbitfield_map[4] = "GL_VERTEX23_BIT_PGI"
	_GLbitfield_map[4] = "GL_UNIFORM_BARRIER_BIT_EXT"
	_GLbitfield_map[4] = "GL_BLUE_BIT_ATI"
	_GLbitfield_map[4] = "GL_UNIFORM_BARRIER_BIT"
	_GLbitfield_map[4] = "GL_COLOR_BUFFER_BIT2_QCOM"
	_GLbitfield_map[4] = "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"
	_GLbitfield_map[4] = "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB"
	_GLbitfield_map[4] = "GL_TRACE_ARRAYS_BIT_MESA"
	_GLbitfield_map[4] = "GL_GEOMETRY_SHADER_BIT"
	_GLbitfield_map[4] = "GL_GEOMETRY_SHADER_BIT_EXT"
	_GLbitfield_map[4] = "GL_GEOMETRY_SHADER_BIT_OES"
	_GLbitfield_map[4] = "GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV"
	_GLbitfield_map[4] = "GL_MAP_INVALIDATE_RANGE_BIT"
	_GLbitfield_map[4] = "GL_MAP_INVALIDATE_RANGE_BIT_EXT"
	_GLbitfield_map[8] = "GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV"
	_GLbitfield_map[8] = "GL_POLYGON_BIT"
	_GLbitfield_map[8] = "GL_HALF_BIT_ATI"
	_GLbitfield_map[8] = "GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR"
	_GLbitfield_map[8] = "GL_COLOR_BUFFER_BIT3_QCOM"
	_GLbitfield_map[8] = "GL_TEXTURE_FETCH_BARRIER_BIT_EXT"
	_GLbitfield_map[8] = "GL_TESS_CONTROL_SHADER_BIT_OES"
	_GLbitfield_map[8] = "GL_TESS_CONTROL_SHADER_BIT_EXT"
	_GLbitfield_map[8] = "GL_TESS_CONTROL_SHADER_BIT"
	_GLbitfield_map[8] = "GL_VERTEX4_BIT_PGI"
	_GLbitfield_map[8] = "GL_BIAS_BIT_ATI"
	_GLbitfield_map[8] = "GL_MAP_INVALIDATE_BUFFER_BIT_EXT"
	_GLbitfield_map[8] = "GL_TRACE_TEXTURES_BIT_MESA"
	_GLbitfield_map[8] = "GL_TEXTURE_FETCH_BARRIER_BIT"
	_GLbitfield_map[8] = "GL_MAP_INVALIDATE_BUFFER_BIT"
	_GLbitfield_map[16] = "GL_TRACE_PIXELS_BIT_MESA"
	_GLbitfield_map[16] = "GL_QUARTER_BIT_ATI"
	_GLbitfield_map[16] = "GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV"
	_GLbitfield_map[16] = "GL_MAP_FLUSH_EXPLICIT_BIT_EXT"
	_GLbitfield_map[16] = "GL_TESS_EVALUATION_SHADER_BIT_OES"
	_GLbitfield_map[16] = "GL_TESS_EVALUATION_SHADER_BIT_EXT"
	_GLbitfield_map[16] = "GL_TESS_EVALUATION_SHADER_BIT"
	_GLbitfield_map[16] = "GL_MAP_FLUSH_EXPLICIT_BIT"
	_GLbitfield_map[16] = "GL_POLYGON_STIPPLE_BIT"
	_GLbitfield_map[16] = "GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV"
	_GLbitfield_map[16] = "GL_COLOR_BUFFER_BIT4_QCOM"
	_GLbitfield_map[32] = "GL_MAP_UNSYNCHRONIZED_BIT_EXT"
	_GLbitfield_map[32] = "GL_EIGHTH_BIT_ATI"
	_GLbitfield_map[32] = "GL_TRACE_ERRORS_BIT_MESA"
	_GLbitfield_map[32] = "GL_COMPUTE_SHADER_BIT"
	_GLbitfield_map[32] = "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT"
	_GLbitfield_map[32] = "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT"
	_GLbitfield_map[32] = "GL_PIXEL_MODE_BIT"
	_GLbitfield_map[32] = "GL_GLYPH_VERTICAL_BEARING_X_BIT_NV"
	_GLbitfield_map[32] = "GL_COLOR_BUFFER_BIT5_QCOM"
	_GLbitfield_map[32] = "GL_MAP_UNSYNCHRONIZED_BIT"
	_GLbitfield_map[64] = "GL_SATURATE_BIT_ATI"
	_GLbitfield_map[64] = "GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV"
	_GLbitfield_map[64] = "GL_COMMAND_BARRIER_BIT_EXT"
	_GLbitfield_map[64] = "GL_COMMAND_BARRIER_BIT"
	_GLbitfield_map[64] = "GL_LIGHTING_BIT"
	_GLbitfield_map[64] = "GL_MAP_PERSISTENT_BIT_EXT"
	_GLbitfield_map[64] = "GL_MAP_PERSISTENT_BIT"
	_GLbitfield_map[64] = "GL_COLOR_BUFFER_BIT6_QCOM"
	_GLbitfield_map[128] = "GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV"
	_GLbitfield_map[128] = "GL_PIXEL_BUFFER_BARRIER_BIT"
	_GLbitfield_map[128] = "GL_MAP_COHERENT_BIT"
	_GLbitfield_map[128] = "GL_PIXEL_BUFFER_BARRIER_BIT_EXT"
	_GLbitfield_map[128] = "GL_MAP_COHERENT_BIT_EXT"
	_GLbitfield_map[128] = "GL_FOG_BIT"
	_GLbitfield_map[128] = "GL_COLOR_BUFFER_BIT7_QCOM"
	_GLbitfield_map[256] = "GL_DYNAMIC_STORAGE_BIT"
	_GLbitfield_map[256] = "GL_GLYPH_HAS_KERNING_BIT_NV"
	_GLbitfield_map[256] = "GL_DEPTH_BUFFER_BIT"
	_GLbitfield_map[256] = "GL_DYNAMIC_STORAGE_BIT_EXT"
	_GLbitfield_map[256] = "GL_TEXTURE_UPDATE_BARRIER_BIT_EXT"
	_GLbitfield_map[256] = "GL_TEXTURE_UPDATE_BARRIER_BIT"
	_GLbitfield_map[256] = "GL_DEPTH_BUFFER_BIT0_QCOM"
	_GLbitfield_map[512] = "GL_CLIENT_STORAGE_BIT"
	_GLbitfield_map[512] = "GL_ACCUM_BUFFER_BIT"
	_GLbitfield_map[512] = "GL_CLIENT_STORAGE_BIT_EXT"
	_GLbitfield_map[512] = "GL_DEPTH_BUFFER_BIT1_QCOM"
	_GLbitfield_map[512] = "GL_BUFFER_UPDATE_BARRIER_BIT_EXT"
	_GLbitfield_map[512] = "GL_BUFFER_UPDATE_BARRIER_BIT"
	_GLbitfield_map[1024] = "GL_DEPTH_BUFFER_BIT2_QCOM"
	_GLbitfield_map[1024] = "GL_STENCIL_BUFFER_BIT"
	_GLbitfield_map[1024] = "GL_FRAMEBUFFER_BARRIER_BIT_EXT"
	_GLbitfield_map[1024] = "GL_FRAMEBUFFER_BARRIER_BIT"
	_GLbitfield_map[1024] = "GL_SPARSE_STORAGE_BIT_ARB"
	_GLbitfield_map[2048] = "GL_VIEWPORT_BIT"
	_GLbitfield_map[2048] = "GL_DEPTH_BUFFER_BIT3_QCOM"
	_GLbitfield_map[2048] = "GL_TRANSFORM_FEEDBACK_BARRIER_BIT"
	_GLbitfield_map[2048] = "GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT"
	_GLbitfield_map[4096] = "GL_DEPTH_BUFFER_BIT4_QCOM"
	_GLbitfield_map[4096] = "GL_ATOMIC_COUNTER_BARRIER_BIT"
	_GLbitfield_map[4096] = "GL_ATOMIC_COUNTER_BARRIER_BIT_EXT"
	_GLbitfield_map[4096] = "GL_TRANSFORM_BIT"
	_GLbitfield_map[8192] = "GL_SHADER_STORAGE_BARRIER_BIT"
	_GLbitfield_map[8192] = "GL_DEPTH_BUFFER_BIT5_QCOM"
	_GLbitfield_map[8192] = "GL_ENABLE_BIT"
	_GLbitfield_map[16384] = "GL_COLOR_BUFFER_BIT"
	_GLbitfield_map[16384] = "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT"
	_GLbitfield_map[16384] = "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT"
	_GLbitfield_map[16384] = "GL_DEPTH_BUFFER_BIT6_QCOM"
	_GLbitfield_map[32768] = "GL_DEPTH_BUFFER_BIT7_QCOM"
	_GLbitfield_map[32768] = "GL_COVERAGE_BUFFER_BIT_NV"
	_GLbitfield_map[32768] = "GL_QUERY_BUFFER_BARRIER_BIT"
	_GLbitfield_map[32768] = "GL_HINT_BIT"
	_GLbitfield_map[65535] = "GL_TRACE_ALL_BITS_MESA"
	_GLbitfield_map[65536] = "GL_STENCIL_BUFFER_BIT0_QCOM"
	_GLbitfield_map[65536] = "GL_COLOR3_BIT_PGI"
	_GLbitfield_map[65536] = "GL_EVAL_BIT"
	_GLbitfield_map[65536] = "GL_FONT_X_MIN_BOUNDS_BIT_NV"
	_GLbitfield_map[131072] = "GL_FONT_Y_MIN_BOUNDS_BIT_NV"
	_GLbitfield_map[131072] = "GL_LIST_BIT"
	_GLbitfield_map[131072] = "GL_STENCIL_BUFFER_BIT1_QCOM"
	_GLbitfield_map[131072] = "GL_COLOR4_BIT_PGI"
	_GLbitfield_map[262144] = "GL_FONT_X_MAX_BOUNDS_BIT_NV"
	_GLbitfield_map[262144] = "GL_TEXTURE_BIT"
	_GLbitfield_map[262144] = "GL_STENCIL_BUFFER_BIT2_QCOM"
	_GLbitfield_map[262144] = "GL_EDGEFLAG_BIT_PGI"
	_GLbitfield_map[524288] = "GL_FONT_Y_MAX_BOUNDS_BIT_NV"
	_GLbitfield_map[524288] = "GL_STENCIL_BUFFER_BIT3_QCOM"
	_GLbitfield_map[524288] = "GL_INDEX_BIT_PGI"
	_GLbitfield_map[524288] = "GL_SCISSOR_BIT"
	_GLbitfield_map[1048576] = "GL_FONT_UNITS_PER_EM_BIT_NV"
	_GLbitfield_map[1048576] = "GL_MAT_AMBIENT_BIT_PGI"
	_GLbitfield_map[1048576] = "GL_STENCIL_BUFFER_BIT4_QCOM"
	_GLbitfield_map[2097152] = "GL_STENCIL_BUFFER_BIT5_QCOM"
	_GLbitfield_map[2097152] = "GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI"
	_GLbitfield_map[2097152] = "GL_FONT_ASCENDER_BIT_NV"
	_GLbitfield_map[4194304] = "GL_FONT_DESCENDER_BIT_NV"
	_GLbitfield_map[4194304] = "GL_STENCIL_BUFFER_BIT6_QCOM"
	_GLbitfield_map[4194304] = "GL_MAT_DIFFUSE_BIT_PGI"
	_GLbitfield_map[8388608] = "GL_FONT_HEIGHT_BIT_NV"
	_GLbitfield_map[8388608] = "GL_STENCIL_BUFFER_BIT7_QCOM"
	_GLbitfield_map[8388608] = "GL_MAT_EMISSION_BIT_PGI"
	_GLbitfield_map[16777216] = "GL_MAT_COLOR_INDEXES_BIT_PGI"
	_GLbitfield_map[16777216] = "GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV"
	_GLbitfield_map[16777216] = "GL_MULTISAMPLE_BUFFER_BIT0_QCOM"
	_GLbitfield_map[33554432] = "GL_MAT_SHININESS_BIT_PGI"
	_GLbitfield_map[33554432] = "GL_MULTISAMPLE_BUFFER_BIT1_QCOM"
	_GLbitfield_map[33554432] = "GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV"
	_GLbitfield_map[67108864] = "GL_MULTISAMPLE_BUFFER_BIT2_QCOM"
	_GLbitfield_map[67108864] = "GL_MAT_SPECULAR_BIT_PGI"
	_GLbitfield_map[67108864] = "GL_FONT_UNDERLINE_POSITION_BIT_NV"
	_GLbitfield_map[134217728] = "GL_FONT_UNDERLINE_THICKNESS_BIT_NV"
	_GLbitfield_map[134217728] = "GL_MULTISAMPLE_BUFFER_BIT3_QCOM"
	_GLbitfield_map[134217728] = "GL_NORMAL_BIT_PGI"
	_GLbitfield_map[268435456] = "GL_MULTISAMPLE_BUFFER_BIT4_QCOM"
	_GLbitfield_map[268435456] = "GL_TEXCOORD1_BIT_PGI"
	_GLbitfield_map[268435456] = "GL_FONT_HAS_KERNING_BIT_NV"
	_GLbitfield_map[536870912] = "GL_TEXCOORD2_BIT_PGI"
	_GLbitfield_map[536870912] = "GL_MULTISAMPLE_BIT_3DFX"
	_GLbitfield_map[536870912] = "GL_MULTISAMPLE_BIT"
	_GLbitfield_map[536870912] = "GL_FONT_NUM_GLYPH_INDICES_BIT_NV"
	_GLbitfield_map[536870912] = "GL_MULTISAMPLE_BIT_EXT"
	_GLbitfield_map[536870912] = "GL_MULTISAMPLE_BUFFER_BIT5_QCOM"
	_GLbitfield_map[536870912] = "GL_MULTISAMPLE_BIT_ARB"
	_GLbitfield_map[1073741824] = "GL_MULTISAMPLE_BUFFER_BIT6_QCOM"
	_GLbitfield_map[1073741824] = "GL_TEXCOORD3_BIT_PGI"
	_GLbitfield_map[2147483648] = "GL_MULTISAMPLE_BUFFER_BIT7_QCOM"
	_GLbitfield_map[2147483648] = "GL_TEXCOORD4_BIT_PGI"
	_GLbitfield_map[4294967295] = "GL_ALL_SHADER_BITS_EXT"
	_GLbitfield_map[4294967295] = "GL_ALL_SHADER_BITS"
	_GLbitfield_map[4294967295] = "GL_ALL_BARRIER_BITS"
	_GLbitfield_map[4294967295] = "GL_CLIENT_ALL_ATTRIB_BITS"
	_GLbitfield_map[4294967295] = "GL_ALL_BARRIER_BITS_EXT"
	_GLbitfield_map[4294967295] = "GL_ALL_ATTRIB_BITS"

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "GLbitfield", Method: schema.Uint32},
		Entries: []schema.Constant{
			{Name: "GL_PERFQUERY_SINGLE_CONTEXT_INTEL", Value: uint32(0)},
			{Name: "GL_RED_BIT_ATI", Value: uint32(1)},
			{Name: "GL_TRACE_OPERATIONS_BIT_MESA", Value: uint32(1)},
			{Name: "GL_2X_BIT_ATI", Value: uint32(1)},
			{Name: "GL_COLOR_BUFFER_BIT0_QCOM", Value: uint32(1)},
			{Name: "GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT", Value: uint32(1)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT", Value: uint32(1)},
			{Name: "GL_CURRENT_BIT", Value: uint32(1)},
			{Name: "GL_VERTEX_SHADER_BIT", Value: uint32(1)},
			{Name: "GL_BOLD_BIT_NV", Value: uint32(1)},
			{Name: "GL_MAP_READ_BIT_EXT", Value: uint32(1)},
			{Name: "GL_SYNC_FLUSH_COMMANDS_BIT", Value: uint32(1)},
			{Name: "GL_SYNC_FLUSH_COMMANDS_BIT_APPLE", Value: uint32(1)},
			{Name: "GL_GLYPH_WIDTH_BIT_NV", Value: uint32(1)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT", Value: uint32(1)},
			{Name: "GL_MAP_READ_BIT", Value: uint32(1)},
			{Name: "GL_CONTEXT_CORE_PROFILE_BIT", Value: uint32(1)},
			{Name: "GL_TEXTURE_DEFORMATION_BIT_SGIX", Value: uint32(1)},
			{Name: "GL_CLIENT_PIXEL_STORE_BIT", Value: uint32(1)},
			{Name: "GL_PERFQUERY_GLOBAL_CONTEXT_INTEL", Value: uint32(1)},
			{Name: "GL_TEXTURE_STORAGE_SPARSE_BIT_AMD", Value: uint32(1)},
			{Name: "GL_VERTEX_SHADER_BIT_EXT", Value: uint32(1)},
			{Name: "GL_CONTEXT_FLAG_DEBUG_BIT_KHR", Value: uint32(2)},
			{Name: "GL_ELEMENT_ARRAY_BARRIER_BIT_EXT", Value: uint32(2)},
			{Name: "GL_MAP_WRITE_BIT_EXT", Value: uint32(2)},
			{Name: "GL_POINT_BIT", Value: uint32(2)},
			{Name: "GL_ELEMENT_ARRAY_BARRIER_BIT", Value: uint32(2)},
			{Name: "GL_4X_BIT_ATI", Value: uint32(2)},
			{Name: "GL_MAP_WRITE_BIT", Value: uint32(2)},
			{Name: "GL_TRACE_PRIMITIVES_BIT_MESA", Value: uint32(2)},
			{Name: "GL_ITALIC_BIT_NV", Value: uint32(2)},
			{Name: "GL_CLIENT_VERTEX_ARRAY_BIT", Value: uint32(2)},
			{Name: "GL_COLOR_BUFFER_BIT1_QCOM", Value: uint32(2)},
			{Name: "GL_GREEN_BIT_ATI", Value: uint32(2)},
			{Name: "GL_GLYPH_HEIGHT_BIT_NV", Value: uint32(2)},
			{Name: "GL_GEOMETRY_DEFORMATION_BIT_SGIX", Value: uint32(2)},
			{Name: "GL_FRAGMENT_SHADER_BIT_EXT", Value: uint32(2)},
			{Name: "GL_FRAGMENT_SHADER_BIT", Value: uint32(2)},
			{Name: "GL_COMP_BIT_ATI", Value: uint32(2)},
			{Name: "GL_CONTEXT_COMPATIBILITY_PROFILE_BIT", Value: uint32(2)},
			{Name: "GL_CONTEXT_FLAG_DEBUG_BIT", Value: uint32(2)},
			{Name: "GL_LINE_BIT", Value: uint32(4)},
			{Name: "GL_NEGATE_BIT_ATI", Value: uint32(4)},
			{Name: "GL_8X_BIT_ATI", Value: uint32(4)},
			{Name: "GL_VERTEX23_BIT_PGI", Value: uint32(4)},
			{Name: "GL_UNIFORM_BARRIER_BIT_EXT", Value: uint32(4)},
			{Name: "GL_BLUE_BIT_ATI", Value: uint32(4)},
			{Name: "GL_UNIFORM_BARRIER_BIT", Value: uint32(4)},
			{Name: "GL_COLOR_BUFFER_BIT2_QCOM", Value: uint32(4)},
			{Name: "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT", Value: uint32(4)},
			{Name: "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB", Value: uint32(4)},
			{Name: "GL_TRACE_ARRAYS_BIT_MESA", Value: uint32(4)},
			{Name: "GL_GEOMETRY_SHADER_BIT", Value: uint32(4)},
			{Name: "GL_GEOMETRY_SHADER_BIT_EXT", Value: uint32(4)},
			{Name: "GL_GEOMETRY_SHADER_BIT_OES", Value: uint32(4)},
			{Name: "GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV", Value: uint32(4)},
			{Name: "GL_MAP_INVALIDATE_RANGE_BIT", Value: uint32(4)},
			{Name: "GL_MAP_INVALIDATE_RANGE_BIT_EXT", Value: uint32(4)},
			{Name: "GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV", Value: uint32(8)},
			{Name: "GL_POLYGON_BIT", Value: uint32(8)},
			{Name: "GL_HALF_BIT_ATI", Value: uint32(8)},
			{Name: "GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR", Value: uint32(8)},
			{Name: "GL_COLOR_BUFFER_BIT3_QCOM", Value: uint32(8)},
			{Name: "GL_TEXTURE_FETCH_BARRIER_BIT_EXT", Value: uint32(8)},
			{Name: "GL_TESS_CONTROL_SHADER_BIT_OES", Value: uint32(8)},
			{Name: "GL_TESS_CONTROL_SHADER_BIT_EXT", Value: uint32(8)},
			{Name: "GL_TESS_CONTROL_SHADER_BIT", Value: uint32(8)},
			{Name: "GL_VERTEX4_BIT_PGI", Value: uint32(8)},
			{Name: "GL_BIAS_BIT_ATI", Value: uint32(8)},
			{Name: "GL_MAP_INVALIDATE_BUFFER_BIT_EXT", Value: uint32(8)},
			{Name: "GL_TRACE_TEXTURES_BIT_MESA", Value: uint32(8)},
			{Name: "GL_TEXTURE_FETCH_BARRIER_BIT", Value: uint32(8)},
			{Name: "GL_MAP_INVALIDATE_BUFFER_BIT", Value: uint32(8)},
			{Name: "GL_TRACE_PIXELS_BIT_MESA", Value: uint32(16)},
			{Name: "GL_QUARTER_BIT_ATI", Value: uint32(16)},
			{Name: "GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV", Value: uint32(16)},
			{Name: "GL_MAP_FLUSH_EXPLICIT_BIT_EXT", Value: uint32(16)},
			{Name: "GL_TESS_EVALUATION_SHADER_BIT_OES", Value: uint32(16)},
			{Name: "GL_TESS_EVALUATION_SHADER_BIT_EXT", Value: uint32(16)},
			{Name: "GL_TESS_EVALUATION_SHADER_BIT", Value: uint32(16)},
			{Name: "GL_MAP_FLUSH_EXPLICIT_BIT", Value: uint32(16)},
			{Name: "GL_POLYGON_STIPPLE_BIT", Value: uint32(16)},
			{Name: "GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV", Value: uint32(16)},
			{Name: "GL_COLOR_BUFFER_BIT4_QCOM", Value: uint32(16)},
			{Name: "GL_MAP_UNSYNCHRONIZED_BIT_EXT", Value: uint32(32)},
			{Name: "GL_EIGHTH_BIT_ATI", Value: uint32(32)},
			{Name: "GL_TRACE_ERRORS_BIT_MESA", Value: uint32(32)},
			{Name: "GL_COMPUTE_SHADER_BIT", Value: uint32(32)},
			{Name: "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT", Value: uint32(32)},
			{Name: "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT", Value: uint32(32)},
			{Name: "GL_PIXEL_MODE_BIT", Value: uint32(32)},
			{Name: "GL_GLYPH_VERTICAL_BEARING_X_BIT_NV", Value: uint32(32)},
			{Name: "GL_COLOR_BUFFER_BIT5_QCOM", Value: uint32(32)},
			{Name: "GL_MAP_UNSYNCHRONIZED_BIT", Value: uint32(32)},
			{Name: "GL_SATURATE_BIT_ATI", Value: uint32(64)},
			{Name: "GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV", Value: uint32(64)},
			{Name: "GL_COMMAND_BARRIER_BIT_EXT", Value: uint32(64)},
			{Name: "GL_COMMAND_BARRIER_BIT", Value: uint32(64)},
			{Name: "GL_LIGHTING_BIT", Value: uint32(64)},
			{Name: "GL_MAP_PERSISTENT_BIT_EXT", Value: uint32(64)},
			{Name: "GL_MAP_PERSISTENT_BIT", Value: uint32(64)},
			{Name: "GL_COLOR_BUFFER_BIT6_QCOM", Value: uint32(64)},
			{Name: "GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV", Value: uint32(128)},
			{Name: "GL_PIXEL_BUFFER_BARRIER_BIT", Value: uint32(128)},
			{Name: "GL_MAP_COHERENT_BIT", Value: uint32(128)},
			{Name: "GL_PIXEL_BUFFER_BARRIER_BIT_EXT", Value: uint32(128)},
			{Name: "GL_MAP_COHERENT_BIT_EXT", Value: uint32(128)},
			{Name: "GL_FOG_BIT", Value: uint32(128)},
			{Name: "GL_COLOR_BUFFER_BIT7_QCOM", Value: uint32(128)},
			{Name: "GL_DYNAMIC_STORAGE_BIT", Value: uint32(256)},
			{Name: "GL_GLYPH_HAS_KERNING_BIT_NV", Value: uint32(256)},
			{Name: "GL_DEPTH_BUFFER_BIT", Value: uint32(256)},
			{Name: "GL_DYNAMIC_STORAGE_BIT_EXT", Value: uint32(256)},
			{Name: "GL_TEXTURE_UPDATE_BARRIER_BIT_EXT", Value: uint32(256)},
			{Name: "GL_TEXTURE_UPDATE_BARRIER_BIT", Value: uint32(256)},
			{Name: "GL_DEPTH_BUFFER_BIT0_QCOM", Value: uint32(256)},
			{Name: "GL_CLIENT_STORAGE_BIT", Value: uint32(512)},
			{Name: "GL_ACCUM_BUFFER_BIT", Value: uint32(512)},
			{Name: "GL_CLIENT_STORAGE_BIT_EXT", Value: uint32(512)},
			{Name: "GL_DEPTH_BUFFER_BIT1_QCOM", Value: uint32(512)},
			{Name: "GL_BUFFER_UPDATE_BARRIER_BIT_EXT", Value: uint32(512)},
			{Name: "GL_BUFFER_UPDATE_BARRIER_BIT", Value: uint32(512)},
			{Name: "GL_DEPTH_BUFFER_BIT2_QCOM", Value: uint32(1024)},
			{Name: "GL_STENCIL_BUFFER_BIT", Value: uint32(1024)},
			{Name: "GL_FRAMEBUFFER_BARRIER_BIT_EXT", Value: uint32(1024)},
			{Name: "GL_FRAMEBUFFER_BARRIER_BIT", Value: uint32(1024)},
			{Name: "GL_SPARSE_STORAGE_BIT_ARB", Value: uint32(1024)},
			{Name: "GL_VIEWPORT_BIT", Value: uint32(2048)},
			{Name: "GL_DEPTH_BUFFER_BIT3_QCOM", Value: uint32(2048)},
			{Name: "GL_TRANSFORM_FEEDBACK_BARRIER_BIT", Value: uint32(2048)},
			{Name: "GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT", Value: uint32(2048)},
			{Name: "GL_DEPTH_BUFFER_BIT4_QCOM", Value: uint32(4096)},
			{Name: "GL_ATOMIC_COUNTER_BARRIER_BIT", Value: uint32(4096)},
			{Name: "GL_ATOMIC_COUNTER_BARRIER_BIT_EXT", Value: uint32(4096)},
			{Name: "GL_TRANSFORM_BIT", Value: uint32(4096)},
			{Name: "GL_SHADER_STORAGE_BARRIER_BIT", Value: uint32(8192)},
			{Name: "GL_DEPTH_BUFFER_BIT5_QCOM", Value: uint32(8192)},
			{Name: "GL_ENABLE_BIT", Value: uint32(8192)},
			{Name: "GL_COLOR_BUFFER_BIT", Value: uint32(16384)},
			{Name: "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT", Value: uint32(16384)},
			{Name: "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT", Value: uint32(16384)},
			{Name: "GL_DEPTH_BUFFER_BIT6_QCOM", Value: uint32(16384)},
			{Name: "GL_DEPTH_BUFFER_BIT7_QCOM", Value: uint32(32768)},
			{Name: "GL_COVERAGE_BUFFER_BIT_NV", Value: uint32(32768)},
			{Name: "GL_QUERY_BUFFER_BARRIER_BIT", Value: uint32(32768)},
			{Name: "GL_HINT_BIT", Value: uint32(32768)},
			{Name: "GL_TRACE_ALL_BITS_MESA", Value: uint32(65535)},
			{Name: "GL_STENCIL_BUFFER_BIT0_QCOM", Value: uint32(65536)},
			{Name: "GL_COLOR3_BIT_PGI", Value: uint32(65536)},
			{Name: "GL_EVAL_BIT", Value: uint32(65536)},
			{Name: "GL_FONT_X_MIN_BOUNDS_BIT_NV", Value: uint32(65536)},
			{Name: "GL_FONT_Y_MIN_BOUNDS_BIT_NV", Value: uint32(131072)},
			{Name: "GL_LIST_BIT", Value: uint32(131072)},
			{Name: "GL_STENCIL_BUFFER_BIT1_QCOM", Value: uint32(131072)},
			{Name: "GL_COLOR4_BIT_PGI", Value: uint32(131072)},
			{Name: "GL_FONT_X_MAX_BOUNDS_BIT_NV", Value: uint32(262144)},
			{Name: "GL_TEXTURE_BIT", Value: uint32(262144)},
			{Name: "GL_STENCIL_BUFFER_BIT2_QCOM", Value: uint32(262144)},
			{Name: "GL_EDGEFLAG_BIT_PGI", Value: uint32(262144)},
			{Name: "GL_FONT_Y_MAX_BOUNDS_BIT_NV", Value: uint32(524288)},
			{Name: "GL_STENCIL_BUFFER_BIT3_QCOM", Value: uint32(524288)},
			{Name: "GL_INDEX_BIT_PGI", Value: uint32(524288)},
			{Name: "GL_SCISSOR_BIT", Value: uint32(524288)},
			{Name: "GL_FONT_UNITS_PER_EM_BIT_NV", Value: uint32(1048576)},
			{Name: "GL_MAT_AMBIENT_BIT_PGI", Value: uint32(1048576)},
			{Name: "GL_STENCIL_BUFFER_BIT4_QCOM", Value: uint32(1048576)},
			{Name: "GL_STENCIL_BUFFER_BIT5_QCOM", Value: uint32(2097152)},
			{Name: "GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI", Value: uint32(2097152)},
			{Name: "GL_FONT_ASCENDER_BIT_NV", Value: uint32(2097152)},
			{Name: "GL_FONT_DESCENDER_BIT_NV", Value: uint32(4194304)},
			{Name: "GL_STENCIL_BUFFER_BIT6_QCOM", Value: uint32(4194304)},
			{Name: "GL_MAT_DIFFUSE_BIT_PGI", Value: uint32(4194304)},
			{Name: "GL_FONT_HEIGHT_BIT_NV", Value: uint32(8388608)},
			{Name: "GL_STENCIL_BUFFER_BIT7_QCOM", Value: uint32(8388608)},
			{Name: "GL_MAT_EMISSION_BIT_PGI", Value: uint32(8388608)},
			{Name: "GL_MAT_COLOR_INDEXES_BIT_PGI", Value: uint32(16777216)},
			{Name: "GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV", Value: uint32(16777216)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT0_QCOM", Value: uint32(16777216)},
			{Name: "GL_MAT_SHININESS_BIT_PGI", Value: uint32(33554432)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT1_QCOM", Value: uint32(33554432)},
			{Name: "GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV", Value: uint32(33554432)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT2_QCOM", Value: uint32(67108864)},
			{Name: "GL_MAT_SPECULAR_BIT_PGI", Value: uint32(67108864)},
			{Name: "GL_FONT_UNDERLINE_POSITION_BIT_NV", Value: uint32(67108864)},
			{Name: "GL_FONT_UNDERLINE_THICKNESS_BIT_NV", Value: uint32(134217728)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT3_QCOM", Value: uint32(134217728)},
			{Name: "GL_NORMAL_BIT_PGI", Value: uint32(134217728)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT4_QCOM", Value: uint32(268435456)},
			{Name: "GL_TEXCOORD1_BIT_PGI", Value: uint32(268435456)},
			{Name: "GL_FONT_HAS_KERNING_BIT_NV", Value: uint32(268435456)},
			{Name: "GL_TEXCOORD2_BIT_PGI", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BIT_3DFX", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BIT", Value: uint32(536870912)},
			{Name: "GL_FONT_NUM_GLYPH_INDICES_BIT_NV", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BIT_EXT", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT5_QCOM", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BIT_ARB", Value: uint32(536870912)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT6_QCOM", Value: uint32(1073741824)},
			{Name: "GL_TEXCOORD3_BIT_PGI", Value: uint32(1073741824)},
			{Name: "GL_MULTISAMPLE_BUFFER_BIT7_QCOM", Value: uint32(2147483648)},
			{Name: "GL_TEXCOORD4_BIT_PGI", Value: uint32(2147483648)},
			{Name: "GL_ALL_SHADER_BITS_EXT", Value: uint32(4294967295)},
			{Name: "GL_ALL_SHADER_BITS", Value: uint32(4294967295)},
			{Name: "GL_ALL_BARRIER_BITS", Value: uint32(4294967295)},
			{Name: "GL_CLIENT_ALL_ATTRIB_BITS", Value: uint32(4294967295)},
			{Name: "GL_ALL_BARRIER_BITS_EXT", Value: uint32(4294967295)},
			{Name: "GL_ALL_ATTRIB_BITS", Value: uint32(4294967295)},
		},
	})
}

func (v GLbitfield) String() string {
	if s, ok := _GLbitfield_map[v]; ok {
		return s
	}
	return fmt.Sprintf("GLbitfield(%d)", v)
}

func (v *GLbitfield) Parse(s string) error {
	for k, t := range _GLbitfield_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in GLbitfield", s)
}

var _GLenum_map = map[GLenum]string{}

func init() {
	_GLenum_map[0] = "GL_TERMINATE_SEQUENCE_COMMAND_NV"
	_GLenum_map[0] = "GL_CLOSE_PATH_NV"
	_GLenum_map[0] = "GL_FALSE"
	_GLenum_map[0] = "GL_ZERO"
	_GLenum_map[0] = "GL_NONE"
	_GLenum_map[0] = "GL_NONE_OES"
	_GLenum_map[0] = "GL_NO_ERROR"
	_GLenum_map[0] = "GL_LAYOUT_DEFAULT_INTEL"
	_GLenum_map[0] = "GL_POINTS"
	_GLenum_map[1] = "GL_TRUE"
	_GLenum_map[1] = "GL_RESTART_SUN"
	_GLenum_map[1] = "GL_VERSION_ES_CM_1_1"
	_GLenum_map[1] = "GL_VERSION_ES_CL_1_1"
	_GLenum_map[1] = "GL_VERSION_ES_CL_1_0"
	_GLenum_map[1] = "GL_ONE"
	_GLenum_map[1] = "GL_LAYOUT_LINEAR_INTEL"
	_GLenum_map[1] = "GL_NOP_COMMAND_NV"
	_GLenum_map[1] = "GL_LINES"
	_GLenum_map[2] = "GL_REPLACE_MIDDLE_SUN"
	_GLenum_map[2] = "GL_DRAW_ELEMENTS_COMMAND_NV"
	_GLenum_map[2] = "GL_LAYOUT_LINEAR_CPU_CACHED_INTEL"
	_GLenum_map[2] = "GL_LINE_LOOP"
	_GLenum_map[2] = "GL_MOVE_TO_NV"
	_GLenum_map[3] = "GL_RELATIVE_MOVE_TO_NV"
	_GLenum_map[3] = "GL_LINE_STRIP"
	_GLenum_map[3] = "GL_DRAW_ARRAYS_COMMAND_NV"
	_GLenum_map[3] = "GL_REPLACE_OLDEST_SUN"
	_GLenum_map[4] = "GL_LINE_TO_NV"
	_GLenum_map[4] = "GL_DRAW_ELEMENTS_STRIP_COMMAND_NV"
	_GLenum_map[4] = "GL_TRIANGLES"
	_GLenum_map[5] = "GL_DRAW_ARRAYS_STRIP_COMMAND_NV"
	_GLenum_map[5] = "GL_TRIANGLE_STRIP"
	_GLenum_map[5] = "GL_RELATIVE_LINE_TO_NV"
	_GLenum_map[6] = "GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV"
	_GLenum_map[6] = "GL_HORIZONTAL_LINE_TO_NV"
	_GLenum_map[6] = "GL_TRIANGLE_FAN"
	_GLenum_map[7] = "GL_QUADS_EXT"
	_GLenum_map[7] = "GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV"
	_GLenum_map[7] = "GL_QUADS"
	_GLenum_map[7] = "GL_RELATIVE_HORIZONTAL_LINE_TO_NV"
	_GLenum_map[7] = "GL_QUADS_OES"
	_GLenum_map[8] = "GL_VERTICAL_LINE_TO_NV"
	_GLenum_map[8] = "GL_QUAD_STRIP"
	_GLenum_map[8] = "GL_ELEMENT_ADDRESS_COMMAND_NV"
	_GLenum_map[9] = "GL_POLYGON"
	_GLenum_map[9] = "GL_RELATIVE_VERTICAL_LINE_TO_NV"
	_GLenum_map[9] = "GL_ATTRIBUTE_ADDRESS_COMMAND_NV"
	_GLenum_map[10] = "GL_LINES_ADJACENCY_EXT"
	_GLenum_map[10] = "GL_LINES_ADJACENCY_ARB"
	_GLenum_map[10] = "GL_LINES_ADJACENCY_OES"
	_GLenum_map[10] = "GL_QUADRATIC_CURVE_TO_NV"
	_GLenum_map[10] = "GL_UNIFORM_ADDRESS_COMMAND_NV"
	_GLenum_map[10] = "GL_LINES_ADJACENCY"
	_GLenum_map[11] = "GL_LINE_STRIP_ADJACENCY_EXT"
	_GLenum_map[11] = "GL_LINE_STRIP_ADJACENCY"
	_GLenum_map[11] = "GL_LINE_STRIP_ADJACENCY_ARB"
	_GLenum_map[11] = "GL_LINE_STRIP_ADJACENCY_OES"
	_GLenum_map[11] = "GL_BLEND_COLOR_COMMAND_NV"
	_GLenum_map[11] = "GL_RELATIVE_QUADRATIC_CURVE_TO_NV"
	_GLenum_map[12] = "GL_TRIANGLES_ADJACENCY_EXT"
	_GLenum_map[12] = "GL_STENCIL_REF_COMMAND_NV"
	_GLenum_map[12] = "GL_TRIANGLES_ADJACENCY_ARB"
	_GLenum_map[12] = "GL_CUBIC_CURVE_TO_NV"
	_GLenum_map[12] = "GL_TRIANGLES_ADJACENCY"
	_GLenum_map[12] = "GL_TRIANGLES_ADJACENCY_OES"
	_GLenum_map[13] = "GL_TRIANGLE_STRIP_ADJACENCY_EXT"
	_GLenum_map[13] = "GL_TRIANGLE_STRIP_ADJACENCY_OES"
	_GLenum_map[13] = "GL_LINE_WIDTH_COMMAND_NV"
	_GLenum_map[13] = "GL_RELATIVE_CUBIC_CURVE_TO_NV"
	_GLenum_map[13] = "GL_TRIANGLE_STRIP_ADJACENCY"
	_GLenum_map[13] = "GL_TRIANGLE_STRIP_ADJACENCY_ARB"
	_GLenum_map[14] = "GL_POLYGON_OFFSET_COMMAND_NV"
	_GLenum_map[14] = "GL_PATCHES"
	_GLenum_map[14] = "GL_PATCHES_OES"
	_GLenum_map[14] = "GL_SMOOTH_QUADRATIC_CURVE_TO_NV"
	_GLenum_map[14] = "GL_PATCHES_EXT"
	_GLenum_map[15] = "GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV"
	_GLenum_map[15] = "GL_ALPHA_REF_COMMAND_NV"
	_GLenum_map[16] = "GL_VIEWPORT_COMMAND_NV"
	_GLenum_map[16] = "GL_SMOOTH_CUBIC_CURVE_TO_NV"
	_GLenum_map[17] = "GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV"
	_GLenum_map[17] = "GL_SCISSOR_COMMAND_NV"
	_GLenum_map[18] = "GL_SMALL_CCW_ARC_TO_NV"
	_GLenum_map[18] = "GL_FRONT_FACE_COMMAND_NV"
	_GLenum_map[19] = "GL_RELATIVE_SMALL_CCW_ARC_TO_NV"
	_GLenum_map[20] = "GL_SMALL_CW_ARC_TO_NV"
	_GLenum_map[21] = "GL_RELATIVE_SMALL_CW_ARC_TO_NV"
	_GLenum_map[22] = "GL_LARGE_CCW_ARC_TO_NV"
	_GLenum_map[23] = "GL_RELATIVE_LARGE_CCW_ARC_TO_NV"
	_GLenum_map[24] = "GL_LARGE_CW_ARC_TO_NV"
	_GLenum_map[25] = "GL_RELATIVE_LARGE_CW_ARC_TO_NV"
	_GLenum_map[26] = "GL_CONIC_CURVE_TO_NV"
	_GLenum_map[27] = "GL_RELATIVE_CONIC_CURVE_TO_NV"
	_GLenum_map[192] = "GL_SHARED_EDGE_NV"
	_GLenum_map[232] = "GL_ROUNDED_RECT_NV"
	_GLenum_map[233] = "GL_RELATIVE_ROUNDED_RECT_NV"
	_GLenum_map[234] = "GL_ROUNDED_RECT2_NV"
	_GLenum_map[235] = "GL_RELATIVE_ROUNDED_RECT2_NV"
	_GLenum_map[236] = "GL_ROUNDED_RECT4_NV"
	_GLenum_map[237] = "GL_RELATIVE_ROUNDED_RECT4_NV"
	_GLenum_map[238] = "GL_ROUNDED_RECT8_NV"
	_GLenum_map[239] = "GL_RELATIVE_ROUNDED_RECT8_NV"
	_GLenum_map[240] = "GL_RESTART_PATH_NV"
	_GLenum_map[242] = "GL_DUP_FIRST_CUBIC_CURVE_TO_NV"
	_GLenum_map[244] = "GL_DUP_LAST_CUBIC_CURVE_TO_NV"
	_GLenum_map[246] = "GL_RECT_NV"
	_GLenum_map[247] = "GL_RELATIVE_RECT_NV"
	_GLenum_map[248] = "GL_CIRCULAR_CCW_ARC_TO_NV"
	_GLenum_map[250] = "GL_CIRCULAR_CW_ARC_TO_NV"
	_GLenum_map[252] = "GL_CIRCULAR_TANGENT_ARC_TO_NV"
	_GLenum_map[254] = "GL_ARC_TO_NV"
	_GLenum_map[255] = "GL_RELATIVE_ARC_TO_NV"
	_GLenum_map[256] = "GL_ACCUM"
	_GLenum_map[257] = "GL_LOAD"
	_GLenum_map[258] = "GL_RETURN"
	_GLenum_map[259] = "GL_MULT"
	_GLenum_map[260] = "GL_ADD"
	_GLenum_map[512] = "GL_NEVER"
	_GLenum_map[513] = "GL_LESS"
	_GLenum_map[514] = "GL_EQUAL"
	_GLenum_map[515] = "GL_LEQUAL"
	_GLenum_map[516] = "GL_GREATER"
	_GLenum_map[517] = "GL_NOTEQUAL"
	_GLenum_map[518] = "GL_GEQUAL"
	_GLenum_map[519] = "GL_ALWAYS"
	_GLenum_map[768] = "GL_SRC_COLOR"
	_GLenum_map[769] = "GL_ONE_MINUS_SRC_COLOR"
	_GLenum_map[770] = "GL_SRC_ALPHA"
	_GLenum_map[771] = "GL_ONE_MINUS_SRC_ALPHA"
	_GLenum_map[772] = "GL_DST_ALPHA"
	_GLenum_map[773] = "GL_ONE_MINUS_DST_ALPHA"
	_GLenum_map[774] = "GL_DST_COLOR"
	_GLenum_map[775] = "GL_ONE_MINUS_DST_COLOR"
	_GLenum_map[776] = "GL_SRC_ALPHA_SATURATE"
	_GLenum_map[1024] = "GL_FRONT_LEFT"
	_GLenum_map[1025] = "GL_FRONT_RIGHT"
	_GLenum_map[1026] = "GL_BACK_LEFT"
	_GLenum_map[1027] = "GL_BACK_RIGHT"
	_GLenum_map[1028] = "GL_FRONT"
	_GLenum_map[1029] = "GL_BACK"
	_GLenum_map[1030] = "GL_LEFT"
	_GLenum_map[1031] = "GL_RIGHT"
	_GLenum_map[1032] = "GL_FRONT_AND_BACK"
	_GLenum_map[1033] = "GL_AUX0"
	_GLenum_map[1034] = "GL_AUX1"
	_GLenum_map[1035] = "GL_AUX2"
	_GLenum_map[1036] = "GL_AUX3"
	_GLenum_map[1280] = "GL_INVALID_ENUM"
	_GLenum_map[1281] = "GL_INVALID_VALUE"
	_GLenum_map[1282] = "GL_INVALID_OPERATION"
	_GLenum_map[1283] = "GL_STACK_OVERFLOW"
	_GLenum_map[1283] = "GL_STACK_OVERFLOW_KHR"
	_GLenum_map[1284] = "GL_STACK_UNDERFLOW"
	_GLenum_map[1284] = "GL_STACK_UNDERFLOW_KHR"
	_GLenum_map[1285] = "GL_OUT_OF_MEMORY"
	_GLenum_map[1286] = "GL_INVALID_FRAMEBUFFER_OPERATION"
	_GLenum_map[1286] = "GL_INVALID_FRAMEBUFFER_OPERATION_OES"
	_GLenum_map[1286] = "GL_INVALID_FRAMEBUFFER_OPERATION_EXT"
	_GLenum_map[1287] = "GL_CONTEXT_LOST_KHR"
	_GLenum_map[1287] = "GL_CONTEXT_LOST"
	_GLenum_map[1536] = "GL_2D"
	_GLenum_map[1537] = "GL_3D"
	_GLenum_map[1538] = "GL_3D_COLOR"
	_GLenum_map[1539] = "GL_3D_COLOR_TEXTURE"
	_GLenum_map[1540] = "GL_4D_COLOR_TEXTURE"
	_GLenum_map[1792] = "GL_PASS_THROUGH_TOKEN"
	_GLenum_map[1793] = "GL_POINT_TOKEN"
	_GLenum_map[1794] = "GL_LINE_TOKEN"
	_GLenum_map[1795] = "GL_POLYGON_TOKEN"
	_GLenum_map[1796] = "GL_BITMAP_TOKEN"
	_GLenum_map[1797] = "GL_DRAW_PIXEL_TOKEN"
	_GLenum_map[1798] = "GL_COPY_PIXEL_TOKEN"
	_GLenum_map[1799] = "GL_LINE_RESET_TOKEN"
	_GLenum_map[2048] = "GL_EXP"
	_GLenum_map[2049] = "GL_EXP2"
	_GLenum_map[2304] = "GL_CW"
	_GLenum_map[2305] = "GL_CCW"
	_GLenum_map[2560] = "GL_COEFF"
	_GLenum_map[2561] = "GL_ORDER"
	_GLenum_map[2562] = "GL_DOMAIN"
	_GLenum_map[2816] = "GL_CURRENT_COLOR"
	_GLenum_map[2817] = "GL_CURRENT_INDEX"
	_GLenum_map[2818] = "GL_CURRENT_NORMAL"
	_GLenum_map[2819] = "GL_CURRENT_TEXTURE_COORDS"
	_GLenum_map[2820] = "GL_CURRENT_RASTER_COLOR"
	_GLenum_map[2821] = "GL_CURRENT_RASTER_INDEX"
	_GLenum_map[2822] = "GL_CURRENT_RASTER_TEXTURE_COORDS"
	_GLenum_map[2823] = "GL_CURRENT_RASTER_POSITION"
	_GLenum_map[2824] = "GL_CURRENT_RASTER_POSITION_VALID"
	_GLenum_map[2825] = "GL_CURRENT_RASTER_DISTANCE"
	_GLenum_map[2832] = "GL_POINT_SMOOTH"
	_GLenum_map[2833] = "GL_POINT_SIZE"
	_GLenum_map[2834] = "GL_SMOOTH_POINT_SIZE_RANGE"
	_GLenum_map[2834] = "GL_POINT_SIZE_RANGE"
	_GLenum_map[2835] = "GL_SMOOTH_POINT_SIZE_GRANULARITY"
	_GLenum_map[2835] = "GL_POINT_SIZE_GRANULARITY"
	_GLenum_map[2848] = "GL_LINE_SMOOTH"
	_GLenum_map[2849] = "GL_LINE_WIDTH"
	_GLenum_map[2850] = "GL_SMOOTH_LINE_WIDTH_RANGE"
	_GLenum_map[2850] = "GL_LINE_WIDTH_RANGE"
	_GLenum_map[2851] = "GL_SMOOTH_LINE_WIDTH_GRANULARITY"
	_GLenum_map[2851] = "GL_LINE_WIDTH_GRANULARITY"
	_GLenum_map[2852] = "GL_LINE_STIPPLE"
	_GLenum_map[2853] = "GL_LINE_STIPPLE_PATTERN"
	_GLenum_map[2854] = "GL_LINE_STIPPLE_REPEAT"
	_GLenum_map[2864] = "GL_LIST_MODE"
	_GLenum_map[2865] = "GL_MAX_LIST_NESTING"
	_GLenum_map[2866] = "GL_LIST_BASE"
	_GLenum_map[2867] = "GL_LIST_INDEX"
	_GLenum_map[2880] = "GL_POLYGON_MODE"
	_GLenum_map[2880] = "GL_POLYGON_MODE_NV"
	_GLenum_map[2881] = "GL_POLYGON_SMOOTH"
	_GLenum_map[2882] = "GL_POLYGON_STIPPLE"
	_GLenum_map[2883] = "GL_EDGE_FLAG"
	_GLenum_map[2884] = "GL_CULL_FACE"
	_GLenum_map[2885] = "GL_CULL_FACE_MODE"
	_GLenum_map[2886] = "GL_FRONT_FACE"
	_GLenum_map[2896] = "GL_LIGHTING"
	_GLenum_map[2897] = "GL_LIGHT_MODEL_LOCAL_VIEWER"
	_GLenum_map[2898] = "GL_LIGHT_MODEL_TWO_SIDE"
	_GLenum_map[2899] = "GL_LIGHT_MODEL_AMBIENT"
	_GLenum_map[2900] = "GL_SHADE_MODEL"
	_GLenum_map[2901] = "GL_COLOR_MATERIAL_FACE"
	_GLenum_map[2902] = "GL_COLOR_MATERIAL_PARAMETER"
	_GLenum_map[2903] = "GL_COLOR_MATERIAL"
	_GLenum_map[2912] = "GL_FOG"
	_GLenum_map[2913] = "GL_FOG_INDEX"
	_GLenum_map[2914] = "GL_FOG_DENSITY"
	_GLenum_map[2915] = "GL_FOG_START"
	_GLenum_map[2916] = "GL_FOG_END"
	_GLenum_map[2917] = "GL_FOG_MODE"
	_GLenum_map[2918] = "GL_FOG_COLOR"
	_GLenum_map[2928] = "GL_DEPTH_RANGE"
	_GLenum_map[2929] = "GL_DEPTH_TEST"
	_GLenum_map[2930] = "GL_DEPTH_WRITEMASK"
	_GLenum_map[2931] = "GL_DEPTH_CLEAR_VALUE"
	_GLenum_map[2932] = "GL_DEPTH_FUNC"
	_GLenum_map[2944] = "GL_ACCUM_CLEAR_VALUE"
	_GLenum_map[2960] = "GL_STENCIL_TEST"
	_GLenum_map[2961] = "GL_STENCIL_CLEAR_VALUE"
	_GLenum_map[2962] = "GL_STENCIL_FUNC"
	_GLenum_map[2963] = "GL_STENCIL_VALUE_MASK"
	_GLenum_map[2964] = "GL_STENCIL_FAIL"
	_GLenum_map[2965] = "GL_STENCIL_PASS_DEPTH_FAIL"
	_GLenum_map[2966] = "GL_STENCIL_PASS_DEPTH_PASS"
	_GLenum_map[2967] = "GL_STENCIL_REF"
	_GLenum_map[2968] = "GL_STENCIL_WRITEMASK"
	_GLenum_map[2976] = "GL_MATRIX_MODE"
	_GLenum_map[2977] = "GL_NORMALIZE"
	_GLenum_map[2978] = "GL_VIEWPORT"
	_GLenum_map[2979] = "GL_MODELVIEW0_STACK_DEPTH_EXT"
	_GLenum_map[2979] = "GL_PATH_MODELVIEW_STACK_DEPTH_NV"
	_GLenum_map[2979] = "GL_MODELVIEW_STACK_DEPTH"
	_GLenum_map[2980] = "GL_PROJECTION_STACK_DEPTH"
	_GLenum_map[2980] = "GL_PATH_PROJECTION_STACK_DEPTH_NV"
	_GLenum_map[2981] = "GL_TEXTURE_STACK_DEPTH"
	_GLenum_map[2982] = "GL_PATH_MODELVIEW_MATRIX_NV"
	_GLenum_map[2982] = "GL_MODELVIEW_MATRIX"
	_GLenum_map[2982] = "GL_MODELVIEW0_MATRIX_EXT"
	_GLenum_map[2983] = "GL_PATH_PROJECTION_MATRIX_NV"
	_GLenum_map[2983] = "GL_PROJECTION_MATRIX"
	_GLenum_map[2984] = "GL_TEXTURE_MATRIX"
	_GLenum_map[2992] = "GL_ATTRIB_STACK_DEPTH"
	_GLenum_map[2993] = "GL_CLIENT_ATTRIB_STACK_DEPTH"
	_GLenum_map[3008] = "GL_ALPHA_TEST_QCOM"
	_GLenum_map[3008] = "GL_ALPHA_TEST"
	_GLenum_map[3009] = "GL_ALPHA_TEST_FUNC_QCOM"
	_GLenum_map[3009] = "GL_ALPHA_TEST_FUNC"
	_GLenum_map[3010] = "GL_ALPHA_TEST_REF_QCOM"
	_GLenum_map[3010] = "GL_ALPHA_TEST_REF"
	_GLenum_map[3024] = "GL_DITHER"
	_GLenum_map[3040] = "GL_BLEND_DST"
	_GLenum_map[3041] = "GL_BLEND_SRC"
	_GLenum_map[3042] = "GL_BLEND"
	_GLenum_map[3056] = "GL_LOGIC_OP_MODE"
	_GLenum_map[3057] = "GL_LOGIC_OP"
	_GLenum_map[3057] = "GL_INDEX_LOGIC_OP"
	_GLenum_map[3058] = "GL_COLOR_LOGIC_OP"
	_GLenum_map[3072] = "GL_AUX_BUFFERS"
	_GLenum_map[3073] = "GL_DRAW_BUFFER_EXT"
	_GLenum_map[3073] = "GL_DRAW_BUFFER"
	_GLenum_map[3074] = "GL_READ_BUFFER"
	_GLenum_map[3074] = "GL_READ_BUFFER_NV"
	_GLenum_map[3074] = "GL_READ_BUFFER_EXT"
	_GLenum_map[3088] = "GL_SCISSOR_BOX"
	_GLenum_map[3089] = "GL_SCISSOR_TEST"
	_GLenum_map[3104] = "GL_INDEX_CLEAR_VALUE"
	_GLenum_map[3105] = "GL_INDEX_WRITEMASK"
	_GLenum_map[3106] = "GL_COLOR_CLEAR_VALUE"
	_GLenum_map[3107] = "GL_COLOR_WRITEMASK"
	_GLenum_map[3120] = "GL_INDEX_MODE"
	_GLenum_map[3121] = "GL_RGBA_MODE"
	_GLenum_map[3122] = "GL_DOUBLEBUFFER"
	_GLenum_map[3123] = "GL_STEREO"
	_GLenum_map[3136] = "GL_RENDER_MODE"
	_GLenum_map[3152] = "GL_PERSPECTIVE_CORRECTION_HINT"
	_GLenum_map[3153] = "GL_POINT_SMOOTH_HINT"
	_GLenum_map[3154] = "GL_LINE_SMOOTH_HINT"
	_GLenum_map[3155] = "GL_POLYGON_SMOOTH_HINT"
	_GLenum_map[3156] = "GL_FOG_HINT"
	_GLenum_map[3168] = "GL_TEXTURE_GEN_S"
	_GLenum_map[3169] = "GL_TEXTURE_GEN_T"
	_GLenum_map[3170] = "GL_TEXTURE_GEN_R"
	_GLenum_map[3171] = "GL_TEXTURE_GEN_Q"
	_GLenum_map[3184] = "GL_PIXEL_MAP_I_TO_I"
	_GLenum_map[3185] = "GL_PIXEL_MAP_S_TO_S"
	_GLenum_map[3186] = "GL_PIXEL_MAP_I_TO_R"
	_GLenum_map[3187] = "GL_PIXEL_MAP_I_TO_G"
	_GLenum_map[3188] = "GL_PIXEL_MAP_I_TO_B"
	_GLenum_map[3189] = "GL_PIXEL_MAP_I_TO_A"
	_GLenum_map[3190] = "GL_PIXEL_MAP_R_TO_R"
	_GLenum_map[3191] = "GL_PIXEL_MAP_G_TO_G"
	_GLenum_map[3192] = "GL_PIXEL_MAP_B_TO_B"
	_GLenum_map[3193] = "GL_PIXEL_MAP_A_TO_A"
	_GLenum_map[3248] = "GL_PIXEL_MAP_I_TO_I_SIZE"
	_GLenum_map[3249] = "GL_PIXEL_MAP_S_TO_S_SIZE"
	_GLenum_map[3250] = "GL_PIXEL_MAP_I_TO_R_SIZE"
	_GLenum_map[3251] = "GL_PIXEL_MAP_I_TO_G_SIZE"
	_GLenum_map[3252] = "GL_PIXEL_MAP_I_TO_B_SIZE"
	_GLenum_map[3253] = "GL_PIXEL_MAP_I_TO_A_SIZE"
	_GLenum_map[3254] = "GL_PIXEL_MAP_R_TO_R_SIZE"
	_GLenum_map[3255] = "GL_PIXEL_MAP_G_TO_G_SIZE"
	_GLenum_map[3256] = "GL_PIXEL_MAP_B_TO_B_SIZE"
	_GLenum_map[3257] = "GL_PIXEL_MAP_A_TO_A_SIZE"
	_GLenum_map[3312] = "GL_UNPACK_SWAP_BYTES"
	_GLenum_map[3313] = "GL_UNPACK_LSB_FIRST"
	_GLenum_map[3314] = "GL_UNPACK_ROW_LENGTH"
	_GLenum_map[3314] = "GL_UNPACK_ROW_LENGTH_EXT"
	_GLenum_map[3315] = "GL_UNPACK_SKIP_ROWS"
	_GLenum_map[3315] = "GL_UNPACK_SKIP_ROWS_EXT"
	_GLenum_map[3316] = "GL_UNPACK_SKIP_PIXELS"
	_GLenum_map[3316] = "GL_UNPACK_SKIP_PIXELS_EXT"
	_GLenum_map[3317] = "GL_UNPACK_ALIGNMENT"
	_GLenum_map[3328] = "GL_PACK_SWAP_BYTES"
	_GLenum_map[3329] = "GL_PACK_LSB_FIRST"
	_GLenum_map[3330] = "GL_PACK_ROW_LENGTH"
	_GLenum_map[3331] = "GL_PACK_SKIP_ROWS"
	_GLenum_map[3332] = "GL_PACK_SKIP_PIXELS"
	_GLenum_map[3333] = "GL_PACK_ALIGNMENT"
	_GLenum_map[3344] = "GL_MAP_COLOR"
	_GLenum_map[3345] = "GL_MAP_STENCIL"
	_GLenum_map[3346] = "GL_INDEX_SHIFT"
	_GLenum_map[3347] = "GL_INDEX_OFFSET"
	_GLenum_map[3348] = "GL_RED_SCALE"
	_GLenum_map[3349] = "GL_RED_BIAS"
	_GLenum_map[3350] = "GL_ZOOM_X"
	_GLenum_map[3351] = "GL_ZOOM_Y"
	_GLenum_map[3352] = "GL_GREEN_SCALE"
	_GLenum_map[3353] = "GL_GREEN_BIAS"
	_GLenum_map[3354] = "GL_BLUE_SCALE"
	_GLenum_map[3355] = "GL_BLUE_BIAS"
	_GLenum_map[3356] = "GL_ALPHA_SCALE"
	_GLenum_map[3357] = "GL_ALPHA_BIAS"
	_GLenum_map[3358] = "GL_DEPTH_SCALE"
	_GLenum_map[3359] = "GL_DEPTH_BIAS"
	_GLenum_map[3376] = "GL_MAX_EVAL_ORDER"
	_GLenum_map[3377] = "GL_MAX_LIGHTS"
	_GLenum_map[3378] = "GL_MAX_CLIP_DISTANCES_APPLE"
	_GLenum_map[3378] = "GL_MAX_CLIP_PLANES"
	_GLenum_map[3378] = "GL_MAX_CLIP_DISTANCES"
	_GLenum_map[3378] = "GL_MAX_CLIP_PLANES_IMG"
	_GLenum_map[3379] = "GL_MAX_TEXTURE_SIZE"
	_GLenum_map[3380] = "GL_MAX_PIXEL_MAP_TABLE"
	_GLenum_map[3381] = "GL_MAX_ATTRIB_STACK_DEPTH"
	_GLenum_map[3382] = "GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV"
	_GLenum_map[3382] = "GL_MAX_MODELVIEW_STACK_DEPTH"
	_GLenum_map[3383] = "GL_MAX_NAME_STACK_DEPTH"
	_GLenum_map[3384] = "GL_MAX_PROJECTION_STACK_DEPTH"
	_GLenum_map[3384] = "GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV"
	_GLenum_map[3385] = "GL_MAX_TEXTURE_STACK_DEPTH"
	_GLenum_map[3386] = "GL_MAX_VIEWPORT_DIMS"
	_GLenum_map[3387] = "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH"
	_GLenum_map[3408] = "GL_SUBPIXEL_BITS"
	_GLenum_map[3409] = "GL_INDEX_BITS"
	_GLenum_map[3410] = "GL_RED_BITS"
	_GLenum_map[3411] = "GL_GREEN_BITS"
	_GLenum_map[3412] = "GL_BLUE_BITS"
	_GLenum_map[3413] = "GL_ALPHA_BITS"
	_GLenum_map[3414] = "GL_DEPTH_BITS"
	_GLenum_map[3415] = "GL_STENCIL_BITS"
	_GLenum_map[3416] = "GL_ACCUM_RED_BITS"
	_GLenum_map[3417] = "GL_ACCUM_GREEN_BITS"
	_GLenum_map[3418] = "GL_ACCUM_BLUE_BITS"
	_GLenum_map[3419] = "GL_ACCUM_ALPHA_BITS"
	_GLenum_map[3440] = "GL_NAME_STACK_DEPTH"
	_GLenum_map[3456] = "GL_AUTO_NORMAL"
	_GLenum_map[3472] = "GL_MAP1_COLOR_4"
	_GLenum_map[3473] = "GL_MAP1_INDEX"
	_GLenum_map[3474] = "GL_MAP1_NORMAL"
	_GLenum_map[3475] = "GL_MAP1_TEXTURE_COORD_1"
	_GLenum_map[3476] = "GL_MAP1_TEXTURE_COORD_2"
	_GLenum_map[3477] = "GL_MAP1_TEXTURE_COORD_3"
	_GLenum_map[3478] = "GL_MAP1_TEXTURE_COORD_4"
	_GLenum_map[3479] = "GL_MAP1_VERTEX_3"
	_GLenum_map[3480] = "GL_MAP1_VERTEX_4"
	_GLenum_map[3504] = "GL_MAP2_COLOR_4"
	_GLenum_map[3505] = "GL_MAP2_INDEX"
	_GLenum_map[3506] = "GL_MAP2_NORMAL"
	_GLenum_map[3507] = "GL_MAP2_TEXTURE_COORD_1"
	_GLenum_map[3508] = "GL_MAP2_TEXTURE_COORD_2"
	_GLenum_map[3509] = "GL_MAP2_TEXTURE_COORD_3"
	_GLenum_map[3510] = "GL_MAP2_TEXTURE_COORD_4"
	_GLenum_map[3511] = "GL_MAP2_VERTEX_3"
	_GLenum_map[3512] = "GL_MAP2_VERTEX_4"
	_GLenum_map[3536] = "GL_MAP1_GRID_DOMAIN"
	_GLenum_map[3537] = "GL_MAP1_GRID_SEGMENTS"
	_GLenum_map[3538] = "GL_MAP2_GRID_DOMAIN"
	_GLenum_map[3539] = "GL_MAP2_GRID_SEGMENTS"
	_GLenum_map[3552] = "GL_TEXTURE_1D"
	_GLenum_map[3553] = "GL_TEXTURE_2D"
	_GLenum_map[3568] = "GL_FEEDBACK_BUFFER_POINTER"
	_GLenum_map[3569] = "GL_FEEDBACK_BUFFER_SIZE"
	_GLenum_map[3570] = "GL_FEEDBACK_BUFFER_TYPE"
	_GLenum_map[3571] = "GL_SELECTION_BUFFER_POINTER"
	_GLenum_map[3572] = "GL_SELECTION_BUFFER_SIZE"
	_GLenum_map[4096] = "GL_TEXTURE_WIDTH"
	_GLenum_map[4097] = "GL_TEXTURE_HEIGHT"
	_GLenum_map[4099] = "GL_TEXTURE_INTERNAL_FORMAT"
	_GLenum_map[4099] = "GL_TEXTURE_COMPONENTS"
	_GLenum_map[4100] = "GL_TEXTURE_BORDER_COLOR_EXT"
	_GLenum_map[4100] = "GL_TEXTURE_BORDER_COLOR_NV"
	_GLenum_map[4100] = "GL_TEXTURE_BORDER_COLOR_OES"
	_GLenum_map[4100] = "GL_TEXTURE_BORDER_COLOR"
	_GLenum_map[4101] = "GL_TEXTURE_BORDER"
	_GLenum_map[4102] = "GL_TEXTURE_TARGET"
	_GLenum_map[4352] = "GL_DONT_CARE"
	_GLenum_map[4353] = "GL_FASTEST"
	_GLenum_map[4354] = "GL_NICEST"
	_GLenum_map[4608] = "GL_AMBIENT"
	_GLenum_map[4609] = "GL_DIFFUSE"
	_GLenum_map[4610] = "GL_SPECULAR"
	_GLenum_map[4611] = "GL_POSITION"
	_GLenum_map[4612] = "GL_SPOT_DIRECTION"
	_GLenum_map[4613] = "GL_SPOT_EXPONENT"
	_GLenum_map[4614] = "GL_SPOT_CUTOFF"
	_GLenum_map[4615] = "GL_CONSTANT_ATTENUATION"
	_GLenum_map[4616] = "GL_LINEAR_ATTENUATION"
	_GLenum_map[4617] = "GL_QUADRATIC_ATTENUATION"
	_GLenum_map[4864] = "GL_COMPILE"
	_GLenum_map[4865] = "GL_COMPILE_AND_EXECUTE"
	_GLenum_map[5120] = "GL_BYTE"
	_GLenum_map[5121] = "GL_UNSIGNED_BYTE"
	_GLenum_map[5122] = "GL_SHORT"
	_GLenum_map[5123] = "GL_UNSIGNED_SHORT"
	_GLenum_map[5124] = "GL_INT"
	_GLenum_map[5125] = "GL_UNSIGNED_INT"
	_GLenum_map[5126] = "GL_FLOAT"
	_GLenum_map[5127] = "GL_2_BYTES"
	_GLenum_map[5127] = "GL_2_BYTES_NV"
	_GLenum_map[5128] = "GL_3_BYTES"
	_GLenum_map[5128] = "GL_3_BYTES_NV"
	_GLenum_map[5129] = "GL_4_BYTES_NV"
	_GLenum_map[5129] = "GL_4_BYTES"
	_GLenum_map[5130] = "GL_DOUBLE_EXT"
	_GLenum_map[5130] = "GL_DOUBLE"
	_GLenum_map[5131] = "GL_HALF_FLOAT_ARB"
	_GLenum_map[5131] = "GL_HALF_FLOAT"
	_GLenum_map[5131] = "GL_HALF_APPLE"
	_GLenum_map[5131] = "GL_HALF_FLOAT_NV"
	_GLenum_map[5132] = "GL_FIXED_OES"
	_GLenum_map[5132] = "GL_FIXED"
	_GLenum_map[5134] = "GL_INT64_NV"
	_GLenum_map[5135] = "GL_UNSIGNED_INT64_ARB"
	_GLenum_map[5135] = "GL_UNSIGNED_INT64_NV"
	_GLenum_map[5376] = "GL_CLEAR"
	_GLenum_map[5377] = "GL_AND"
	_GLenum_map[5378] = "GL_AND_REVERSE"
	_GLenum_map[5379] = "GL_COPY"
	_GLenum_map[5380] = "GL_AND_INVERTED"
	_GLenum_map[5381] = "GL_NOOP"
	_GLenum_map[5382] = "GL_XOR_NV"
	_GLenum_map[5382] = "GL_XOR"
	_GLenum_map[5383] = "GL_OR"
	_GLenum_map[5384] = "GL_NOR"
	_GLenum_map[5385] = "GL_EQUIV"
	_GLenum_map[5386] = "GL_INVERT"
	_GLenum_map[5387] = "GL_OR_REVERSE"
	_GLenum_map[5388] = "GL_COPY_INVERTED"
	_GLenum_map[5389] = "GL_OR_INVERTED"
	_GLenum_map[5390] = "GL_NAND"
	_GLenum_map[5391] = "GL_SET"
	_GLenum_map[5632] = "GL_EMISSION"
	_GLenum_map[5633] = "GL_SHININESS"
	_GLenum_map[5634] = "GL_AMBIENT_AND_DIFFUSE"
	_GLenum_map[5635] = "GL_COLOR_INDEXES"
	_GLenum_map[5888] = "GL_MODELVIEW"
	_GLenum_map[5888] = "GL_MODELVIEW0_EXT"
	_GLenum_map[5888] = "GL_MODELVIEW0_ARB"
	_GLenum_map[5888] = "GL_PATH_MODELVIEW_NV"
	_GLenum_map[5889] = "GL_PATH_PROJECTION_NV"
	_GLenum_map[5889] = "GL_PROJECTION"
	_GLenum_map[5890] = "GL_TEXTURE"
	_GLenum_map[6144] = "GL_COLOR"
	_GLenum_map[6144] = "GL_COLOR_EXT"
	_GLenum_map[6145] = "GL_DEPTH_EXT"
	_GLenum_map[6145] = "GL_DEPTH"
	_GLenum_map[6146] = "GL_STENCIL_EXT"
	_GLenum_map[6146] = "GL_STENCIL"
	_GLenum_map[6400] = "GL_COLOR_INDEX"
	_GLenum_map[6401] = "GL_STENCIL_INDEX_OES"
	_GLenum_map[6401] = "GL_STENCIL_INDEX"
	_GLenum_map[6402] = "GL_DEPTH_COMPONENT"
	_GLenum_map[6403] = "GL_RED"
	_GLenum_map[6403] = "GL_RED_NV"
	_GLenum_map[6403] = "GL_RED_EXT"
	_GLenum_map[6404] = "GL_GREEN_NV"
	_GLenum_map[6404] = "GL_GREEN"
	_GLenum_map[6405] = "GL_BLUE"
	_GLenum_map[6405] = "GL_BLUE_NV"
	_GLenum_map[6406] = "GL_ALPHA"
	_GLenum_map[6407] = "GL_RGB"
	_GLenum_map[6408] = "GL_RGBA"
	_GLenum_map[6409] = "GL_LUMINANCE"
	_GLenum_map[6410] = "GL_LUMINANCE_ALPHA"
	_GLenum_map[6656] = "GL_BITMAP"
	_GLenum_map[6912] = "GL_POINT_NV"
	_GLenum_map[6912] = "GL_POINT"
	_GLenum_map[6913] = "GL_LINE_NV"
	_GLenum_map[6913] = "GL_LINE"
	_GLenum_map[6914] = "GL_FILL"
	_GLenum_map[6914] = "GL_FILL_NV"
	_GLenum_map[7168] = "GL_RENDER"
	_GLenum_map[7169] = "GL_FEEDBACK"
	_GLenum_map[7170] = "GL_SELECT"
	_GLenum_map[7424] = "GL_FLAT"
	_GLenum_map[7425] = "GL_SMOOTH"
	_GLenum_map[7680] = "GL_KEEP"
	_GLenum_map[7681] = "GL_REPLACE"
	_GLenum_map[7682] = "GL_INCR"
	_GLenum_map[7683] = "GL_DECR"
	_GLenum_map[7936] = "GL_VENDOR"
	_GLenum_map[7937] = "GL_RENDERER"
	_GLenum_map[7938] = "GL_VERSION"
	_GLenum_map[7939] = "GL_EXTENSIONS"
	_GLenum_map[8192] = "GL_S"
	_GLenum_map[8193] = "GL_T"
	_GLenum_map[8194] = "GL_R"
	_GLenum_map[8195] = "GL_Q"
	_GLenum_map[8448] = "GL_MODULATE"
	_GLenum_map[8449] = "GL_DECAL"
	_GLenum_map[8704] = "GL_TEXTURE_ENV_MODE"
	_GLenum_map[8705] = "GL_TEXTURE_ENV_COLOR"
	_GLenum_map[8960] = "GL_TEXTURE_ENV"
	_GLenum_map[9216] = "GL_EYE_LINEAR_NV"
	_GLenum_map[9216] = "GL_EYE_LINEAR"
	_GLenum_map[9217] = "GL_OBJECT_LINEAR_NV"
	_GLenum_map[9217] = "GL_OBJECT_LINEAR"
	_GLenum_map[9218] = "GL_SPHERE_MAP"
	_GLenum_map[9472] = "GL_TEXTURE_GEN_MODE"
	_GLenum_map[9472] = "GL_TEXTURE_GEN_MODE_OES"
	_GLenum_map[9473] = "GL_OBJECT_PLANE"
	_GLenum_map[9474] = "GL_EYE_PLANE"
	_GLenum_map[9728] = "GL_NEAREST"
	_GLenum_map[9729] = "GL_LINEAR"
	_GLenum_map[9984] = "GL_NEAREST_MIPMAP_NEAREST"
	_GLenum_map[9985] = "GL_LINEAR_MIPMAP_NEAREST"
	_GLenum_map[9986] = "GL_NEAREST_MIPMAP_LINEAR"
	_GLenum_map[9987] = "GL_LINEAR_MIPMAP_LINEAR"
	_GLenum_map[10240] = "GL_TEXTURE_MAG_FILTER"
	_GLenum_map[10241] = "GL_TEXTURE_MIN_FILTER"
	_GLenum_map[10242] = "GL_TEXTURE_WRAP_S"
	_GLenum_map[10243] = "GL_TEXTURE_WRAP_T"
	_GLenum_map[10496] = "GL_CLAMP"
	_GLenum_map[10497] = "GL_REPEAT"
	_GLenum_map[10752] = "GL_POLYGON_OFFSET_UNITS"
	_GLenum_map[10753] = "GL_POLYGON_OFFSET_POINT"
	_GLenum_map[10753] = "GL_POLYGON_OFFSET_POINT_NV"
	_GLenum_map[10754] = "GL_POLYGON_OFFSET_LINE_NV"
	_GLenum_map[10754] = "GL_POLYGON_OFFSET_LINE"
	_GLenum_map[10768] = "GL_R3_G3_B2"
	_GLenum_map[10784] = "GL_V2F"
	_GLenum_map[10785] = "GL_V3F"
	_GLenum_map[10786] = "GL_C4UB_V2F"
	_GLenum_map[10787] = "GL_C4UB_V3F"
	_GLenum_map[10788] = "GL_C3F_V3F"
	_GLenum_map[10789] = "GL_N3F_V3F"
	_GLenum_map[10790] = "GL_C4F_N3F_V3F"
	_GLenum_map[10791] = "GL_T2F_V3F"
	_GLenum_map[10792] = "GL_T4F_V4F"
	_GLenum_map[10793] = "GL_T2F_C4UB_V3F"
	_GLenum_map[10794] = "GL_T2F_C3F_V3F"
	_GLenum_map[10795] = "GL_T2F_N3F_V3F"
	_GLenum_map[10796] = "GL_T2F_C4F_N3F_V3F"
	_GLenum_map[10797] = "GL_T4F_C4F_N3F_V4F"
	_GLenum_map[12288] = "GL_CLIP_DISTANCE0"
	_GLenum_map[12288] = "GL_CLIP_DISTANCE0_APPLE"
	_GLenum_map[12288] = "GL_CLIP_PLANE0"
	_GLenum_map[12288] = "GL_CLIP_PLANE0_IMG"
	_GLenum_map[12289] = "GL_CLIP_DISTANCE1"
	_GLenum_map[12289] = "GL_CLIP_PLANE1_IMG"
	_GLenum_map[12289] = "GL_CLIP_DISTANCE1_APPLE"
	_GLenum_map[12289] = "GL_CLIP_PLANE1"
	_GLenum_map[12290] = "GL_CLIP_DISTANCE2_APPLE"
	_GLenum_map[12290] = "GL_CLIP_PLANE2_IMG"
	_GLenum_map[12290] = "GL_CLIP_DISTANCE2"
	_GLenum_map[12290] = "GL_CLIP_PLANE2"
	_GLenum_map[12291] = "GL_CLIP_PLANE3"
	_GLenum_map[12291] = "GL_CLIP_DISTANCE3"
	_GLenum_map[12291] = "GL_CLIP_DISTANCE3_APPLE"
	_GLenum_map[12291] = "GL_CLIP_PLANE3_IMG"
	_GLenum_map[12292] = "GL_CLIP_PLANE4"
	_GLenum_map[12292] = "GL_CLIP_DISTANCE4_APPLE"
	_GLenum_map[12292] = "GL_CLIP_DISTANCE4"
	_GLenum_map[12292] = "GL_CLIP_PLANE4_IMG"
	_GLenum_map[12293] = "GL_CLIP_PLANE5_IMG"
	_GLenum_map[12293] = "GL_CLIP_DISTANCE5"
	_GLenum_map[12293] = "GL_CLIP_PLANE5"
	_GLenum_map[12293] = "GL_CLIP_DISTANCE5_APPLE"
	_GLenum_map[12294] = "GL_CLIP_DISTANCE6_APPLE"
	_GLenum_map[12294] = "GL_CLIP_DISTANCE6"
	_GLenum_map[12295] = "GL_CLIP_DISTANCE7"
	_GLenum_map[12295] = "GL_CLIP_DISTANCE7_APPLE"
	_GLenum_map[16384] = "GL_LIGHT0"
	_GLenum_map[16385] = "GL_LIGHT1"
	_GLenum_map[16386] = "GL_LIGHT2"
	_GLenum_map[16387] = "GL_LIGHT3"
	_GLenum_map[16388] = "GL_LIGHT4"
	_GLenum_map[16389] = "GL_LIGHT5"
	_GLenum_map[16390] = "GL_LIGHT6"
	_GLenum_map[16391] = "GL_LIGHT7"
	_GLenum_map[32768] = "GL_ABGR_EXT"
	_GLenum_map[32769] = "GL_CONSTANT_COLOR_EXT"
	_GLenum_map[32769] = "GL_CONSTANT_COLOR"
	_GLenum_map[32770] = "GL_ONE_MINUS_CONSTANT_COLOR_EXT"
	_GLenum_map[32770] = "GL_ONE_MINUS_CONSTANT_COLOR"
	_GLenum_map[32771] = "GL_CONSTANT_ALPHA"
	_GLenum_map[32771] = "GL_CONSTANT_ALPHA_EXT"
	_GLenum_map[32772] = "GL_ONE_MINUS_CONSTANT_ALPHA"
	_GLenum_map[32772] = "GL_ONE_MINUS_CONSTANT_ALPHA_EXT"
	_GLenum_map[32773] = "GL_BLEND_COLOR"
	_GLenum_map[32773] = "GL_BLEND_COLOR_EXT"
	_GLenum_map[32774] = "GL_FUNC_ADD_OES"
	_GLenum_map[32774] = "GL_FUNC_ADD"
	_GLenum_map[32774] = "GL_FUNC_ADD_EXT"
	_GLenum_map[32775] = "GL_MIN_EXT"
	_GLenum_map[32775] = "GL_MIN"
	_GLenum_map[32776] = "GL_MAX_EXT"
	_GLenum_map[32776] = "GL_MAX"
	_GLenum_map[32777] = "GL_BLEND_EQUATION_EXT"
	_GLenum_map[32777] = "GL_BLEND_EQUATION_RGB_OES"
	_GLenum_map[32777] = "GL_BLEND_EQUATION_OES"
	_GLenum_map[32777] = "GL_BLEND_EQUATION"
	_GLenum_map[32777] = "GL_BLEND_EQUATION_RGB"
	_GLenum_map[32777] = "GL_BLEND_EQUATION_RGB_EXT"
	_GLenum_map[32778] = "GL_FUNC_SUBTRACT_OES"
	_GLenum_map[32778] = "GL_FUNC_SUBTRACT"
	_GLenum_map[32778] = "GL_FUNC_SUBTRACT_EXT"
	_GLenum_map[32779] = "GL_FUNC_REVERSE_SUBTRACT_OES"
	_GLenum_map[32779] = "GL_FUNC_REVERSE_SUBTRACT"
	_GLenum_map[32779] = "GL_FUNC_REVERSE_SUBTRACT_EXT"
	_GLenum_map[32780] = "GL_CMYK_EXT"
	_GLenum_map[32781] = "GL_CMYKA_EXT"
	_GLenum_map[32782] = "GL_PACK_CMYK_HINT_EXT"
	_GLenum_map[32783] = "GL_UNPACK_CMYK_HINT_EXT"
	_GLenum_map[32784] = "GL_CONVOLUTION_1D_EXT"
	_GLenum_map[32784] = "GL_CONVOLUTION_1D"
	_GLenum_map[32785] = "GL_CONVOLUTION_2D"
	_GLenum_map[32785] = "GL_CONVOLUTION_2D_EXT"
	_GLenum_map[32786] = "GL_SEPARABLE_2D_EXT"
	_GLenum_map[32786] = "GL_SEPARABLE_2D"
	_GLenum_map[32787] = "GL_CONVOLUTION_BORDER_MODE_EXT"
	_GLenum_map[32787] = "GL_CONVOLUTION_BORDER_MODE"
	_GLenum_map[32788] = "GL_CONVOLUTION_FILTER_SCALE_EXT"
	_GLenum_map[32788] = "GL_CONVOLUTION_FILTER_SCALE"
	_GLenum_map[32789] = "GL_CONVOLUTION_FILTER_BIAS_EXT"
	_GLenum_map[32789] = "GL_CONVOLUTION_FILTER_BIAS"
	_GLenum_map[32790] = "GL_REDUCE"
	_GLenum_map[32790] = "GL_REDUCE_EXT"
	_GLenum_map[32791] = "GL_CONVOLUTION_FORMAT"
	_GLenum_map[32791] = "GL_CONVOLUTION_FORMAT_EXT"
	_GLenum_map[32792] = "GL_CONVOLUTION_WIDTH_EXT"
	_GLenum_map[32792] = "GL_CONVOLUTION_WIDTH"
	_GLenum_map[32793] = "GL_CONVOLUTION_HEIGHT"
	_GLenum_map[32793] = "GL_CONVOLUTION_HEIGHT_EXT"
	_GLenum_map[32794] = "GL_MAX_CONVOLUTION_WIDTH"
	_GLenum_map[32794] = "GL_MAX_CONVOLUTION_WIDTH_EXT"
	_GLenum_map[32795] = "GL_MAX_CONVOLUTION_HEIGHT_EXT"
	_GLenum_map[32795] = "GL_MAX_CONVOLUTION_HEIGHT"
	_GLenum_map[32796] = "GL_POST_CONVOLUTION_RED_SCALE"
	_GLenum_map[32796] = "GL_POST_CONVOLUTION_RED_SCALE_EXT"
	_GLenum_map[32797] = "GL_POST_CONVOLUTION_GREEN_SCALE_EXT"
	_GLenum_map[32797] = "GL_POST_CONVOLUTION_GREEN_SCALE"
	_GLenum_map[32798] = "GL_POST_CONVOLUTION_BLUE_SCALE"
	_GLenum_map[32798] = "GL_POST_CONVOLUTION_BLUE_SCALE_EXT"
	_GLenum_map[32799] = "GL_POST_CONVOLUTION_ALPHA_SCALE"
	_GLenum_map[32799] = "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT"
	_GLenum_map[32800] = "GL_POST_CONVOLUTION_RED_BIAS_EXT"
	_GLenum_map[32800] = "GL_POST_CONVOLUTION_RED_BIAS"
	_GLenum_map[32801] = "GL_POST_CONVOLUTION_GREEN_BIAS_EXT"
	_GLenum_map[32801] = "GL_POST_CONVOLUTION_GREEN_BIAS"
	_GLenum_map[32802] = "GL_POST_CONVOLUTION_BLUE_BIAS"
	_GLenum_map[32802] = "GL_POST_CONVOLUTION_BLUE_BIAS_EXT"
	_GLenum_map[32803] = "GL_POST_CONVOLUTION_ALPHA_BIAS"
	_GLenum_map[32803] = "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT"
	_GLenum_map[32804] = "GL_HISTOGRAM"
	_GLenum_map[32804] = "GL_HISTOGRAM_EXT"
	_GLenum_map[32805] = "GL_PROXY_HISTOGRAM_EXT"
	_GLenum_map[32805] = "GL_PROXY_HISTOGRAM"
	_GLenum_map[32806] = "GL_HISTOGRAM_WIDTH"
	_GLenum_map[32806] = "GL_HISTOGRAM_WIDTH_EXT"
	_GLenum_map[32807] = "GL_HISTOGRAM_FORMAT_EXT"
	_GLenum_map[32807] = "GL_HISTOGRAM_FORMAT"
	_GLenum_map[32808] = "GL_HISTOGRAM_RED_SIZE"
	_GLenum_map[32808] = "GL_HISTOGRAM_RED_SIZE_EXT"
	_GLenum_map[32809] = "GL_HISTOGRAM_GREEN_SIZE"
	_GLenum_map[32809] = "GL_HISTOGRAM_GREEN_SIZE_EXT"
	_GLenum_map[32810] = "GL_HISTOGRAM_BLUE_SIZE"
	_GLenum_map[32810] = "GL_HISTOGRAM_BLUE_SIZE_EXT"
	_GLenum_map[32811] = "GL_HISTOGRAM_ALPHA_SIZE"
	_GLenum_map[32811] = "GL_HISTOGRAM_ALPHA_SIZE_EXT"
	_GLenum_map[32812] = "GL_HISTOGRAM_LUMINANCE_SIZE_EXT"
	_GLenum_map[32812] = "GL_HISTOGRAM_LUMINANCE_SIZE"
	_GLenum_map[32813] = "GL_HISTOGRAM_SINK"
	_GLenum_map[32813] = "GL_HISTOGRAM_SINK_EXT"
	_GLenum_map[32814] = "GL_MINMAX"
	_GLenum_map[32814] = "GL_MINMAX_EXT"
	_GLenum_map[32815] = "GL_MINMAX_FORMAT_EXT"
	_GLenum_map[32815] = "GL_MINMAX_FORMAT"
	_GLenum_map[32816] = "GL_MINMAX_SINK"
	_GLenum_map[32816] = "GL_MINMAX_SINK_EXT"
	_GLenum_map[32817] = "GL_TABLE_TOO_LARGE_EXT"
	_GLenum_map[32817] = "GL_TABLE_TOO_LARGE"
	_GLenum_map[32818] = "GL_UNSIGNED_BYTE_3_3_2_EXT"
	_GLenum_map[32818] = "GL_UNSIGNED_BYTE_3_3_2"
	_GLenum_map[32819] = "GL_UNSIGNED_SHORT_4_4_4_4"
	_GLenum_map[32819] = "GL_UNSIGNED_SHORT_4_4_4_4_EXT"
	_GLenum_map[32820] = "GL_UNSIGNED_SHORT_5_5_5_1"
	_GLenum_map[32820] = "GL_UNSIGNED_SHORT_5_5_5_1_EXT"
	_GLenum_map[32821] = "GL_UNSIGNED_INT_8_8_8_8_EXT"
	_GLenum_map[32821] = "GL_UNSIGNED_INT_8_8_8_8"
	_GLenum_map[32822] = "GL_UNSIGNED_INT_10_10_10_2_EXT"
	_GLenum_map[32822] = "GL_UNSIGNED_INT_10_10_10_2"
	_GLenum_map[32823] = "GL_POLYGON_OFFSET_EXT"
	_GLenum_map[32823] = "GL_POLYGON_OFFSET_FILL"
	_GLenum_map[32824] = "GL_POLYGON_OFFSET_FACTOR"
	_GLenum_map[32824] = "GL_POLYGON_OFFSET_FACTOR_EXT"
	_GLenum_map[32825] = "GL_POLYGON_OFFSET_BIAS_EXT"
	_GLenum_map[32826] = "GL_RESCALE_NORMAL_EXT"
	_GLenum_map[32826] = "GL_RESCALE_NORMAL"
	_GLenum_map[32827] = "GL_ALPHA4_EXT"
	_GLenum_map[32827] = "GL_ALPHA4"
	_GLenum_map[32828] = "GL_ALPHA8_EXT"
	_GLenum_map[32828] = "GL_ALPHA8_OES"
	_GLenum_map[32828] = "GL_ALPHA8"
	_GLenum_map[32829] = "GL_ALPHA12"
	_GLenum_map[32829] = "GL_ALPHA12_EXT"
	_GLenum_map[32830] = "GL_ALPHA16"
	_GLenum_map[32830] = "GL_ALPHA16_EXT"
	_GLenum_map[32831] = "GL_LUMINANCE4"
	_GLenum_map[32831] = "GL_LUMINANCE4_EXT"
	_GLenum_map[32832] = "GL_LUMINANCE8_OES"
	_GLenum_map[32832] = "GL_LUMINANCE8_EXT"
	_GLenum_map[32832] = "GL_LUMINANCE8"
	_GLenum_map[32833] = "GL_LUMINANCE12_EXT"
	_GLenum_map[32833] = "GL_LUMINANCE12"
	_GLenum_map[32834] = "GL_LUMINANCE16_EXT"
	_GLenum_map[32834] = "GL_LUMINANCE16"
	_GLenum_map[32835] = "GL_LUMINANCE4_ALPHA4_OES"
	_GLenum_map[32835] = "GL_LUMINANCE4_ALPHA4"
	_GLenum_map[32835] = "GL_LUMINANCE4_ALPHA4_EXT"
	_GLenum_map[32836] = "GL_LUMINANCE6_ALPHA2"
	_GLenum_map[32836] = "GL_LUMINANCE6_ALPHA2_EXT"
	_GLenum_map[32837] = "GL_LUMINANCE8_ALPHA8_EXT"
	_GLenum_map[32837] = "GL_LUMINANCE8_ALPHA8"
	_GLenum_map[32837] = "GL_LUMINANCE8_ALPHA8_OES"
	_GLenum_map[32838] = "GL_LUMINANCE12_ALPHA4"
	_GLenum_map[32838] = "GL_LUMINANCE12_ALPHA4_EXT"
	_GLenum_map[32839] = "GL_LUMINANCE12_ALPHA12_EXT"
	_GLenum_map[32839] = "GL_LUMINANCE12_ALPHA12"
	_GLenum_map[32840] = "GL_LUMINANCE16_ALPHA16_EXT"
	_GLenum_map[32840] = "GL_LUMINANCE16_ALPHA16"
	_GLenum_map[32841] = "GL_INTENSITY_EXT"
	_GLenum_map[32841] = "GL_INTENSITY"
	_GLenum_map[32842] = "GL_INTENSITY4"
	_GLenum_map[32842] = "GL_INTENSITY4_EXT"
	_GLenum_map[32843] = "GL_INTENSITY8_EXT"
	_GLenum_map[32843] = "GL_INTENSITY8"
	_GLenum_map[32844] = "GL_INTENSITY12"
	_GLenum_map[32844] = "GL_INTENSITY12_EXT"
	_GLenum_map[32845] = "GL_INTENSITY16"
	_GLenum_map[32845] = "GL_INTENSITY16_EXT"
	_GLenum_map[32846] = "GL_RGB2_EXT"
	_GLenum_map[32847] = "GL_RGB4"
	_GLenum_map[32847] = "GL_RGB4_EXT"
	_GLenum_map[32848] = "GL_RGB5_EXT"
	_GLenum_map[32848] = "GL_RGB5"
	_GLenum_map[32849] = "GL_RGB8"
	_GLenum_map[32849] = "GL_RGB8_OES"
	_GLenum_map[32849] = "GL_RGB8_EXT"
	_GLenum_map[32850] = "GL_RGB10_EXT"
	_GLenum_map[32850] = "GL_RGB10"
	_GLenum_map[32851] = "GL_RGB12"
	_GLenum_map[32851] = "GL_RGB12_EXT"
	_GLenum_map[32852] = "GL_RGB16"
	_GLenum_map[32852] = "GL_RGB16_EXT"
	_GLenum_map[32853] = "GL_RGBA2"
	_GLenum_map[32853] = "GL_RGBA2_EXT"
	_GLenum_map[32854] = "GL_RGBA4_EXT"
	_GLenum_map[32854] = "GL_RGBA4_OES"
	_GLenum_map[32854] = "GL_RGBA4"
	_GLenum_map[32855] = "GL_RGB5_A1_OES"
	_GLenum_map[32855] = "GL_RGB5_A1"
	_GLenum_map[32855] = "GL_RGB5_A1_EXT"
	_GLenum_map[32856] = "GL_RGBA8_EXT"
	_GLenum_map[32856] = "GL_RGBA8"
	_GLenum_map[32856] = "GL_RGBA8_OES"
	_GLenum_map[32857] = "GL_RGB10_A2_EXT"
	_GLenum_map[32857] = "GL_RGB10_A2"
	_GLenum_map[32858] = "GL_RGBA12_EXT"
	_GLenum_map[32858] = "GL_RGBA12"
	_GLenum_map[32859] = "GL_RGBA16"
	_GLenum_map[32859] = "GL_RGBA16_EXT"
	_GLenum_map[32860] = "GL_TEXTURE_RED_SIZE_EXT"
	_GLenum_map[32860] = "GL_TEXTURE_RED_SIZE"
	_GLenum_map[32861] = "GL_TEXTURE_GREEN_SIZE"
	_GLenum_map[32861] = "GL_TEXTURE_GREEN_SIZE_EXT"
	_GLenum_map[32862] = "GL_TEXTURE_BLUE_SIZE_EXT"
	_GLenum_map[32862] = "GL_TEXTURE_BLUE_SIZE"
	_GLenum_map[32863] = "GL_TEXTURE_ALPHA_SIZE_EXT"
	_GLenum_map[32863] = "GL_TEXTURE_ALPHA_SIZE"
	_GLenum_map[32864] = "GL_TEXTURE_LUMINANCE_SIZE_EXT"
	_GLenum_map[32864] = "GL_TEXTURE_LUMINANCE_SIZE"
	_GLenum_map[32865] = "GL_TEXTURE_INTENSITY_SIZE"
	_GLenum_map[32865] = "GL_TEXTURE_INTENSITY_SIZE_EXT"
	_GLenum_map[32866] = "GL_REPLACE_EXT"
	_GLenum_map[32867] = "GL_PROXY_TEXTURE_1D_EXT"
	_GLenum_map[32867] = "GL_PROXY_TEXTURE_1D"
	_GLenum_map[32868] = "GL_PROXY_TEXTURE_2D_EXT"
	_GLenum_map[32868] = "GL_PROXY_TEXTURE_2D"
	_GLenum_map[32869] = "GL_TEXTURE_TOO_LARGE_EXT"
	_GLenum_map[32870] = "GL_TEXTURE_PRIORITY"
	_GLenum_map[32870] = "GL_TEXTURE_PRIORITY_EXT"
	_GLenum_map[32871] = "GL_TEXTURE_RESIDENT"
	_GLenum_map[32871] = "GL_TEXTURE_RESIDENT_EXT"
	_GLenum_map[32872] = "GL_TEXTURE_1D_BINDING_EXT"
	_GLenum_map[32872] = "GL_TEXTURE_BINDING_1D"
	_GLenum_map[32873] = "GL_TEXTURE_2D_BINDING_EXT"
	_GLenum_map[32873] = "GL_TEXTURE_BINDING_2D"
	_GLenum_map[32874] = "GL_TEXTURE_BINDING_3D_OES"
	_GLenum_map[32874] = "GL_TEXTURE_3D_BINDING_OES"
	_GLenum_map[32874] = "GL_TEXTURE_BINDING_3D"
	_GLenum_map[32874] = "GL_TEXTURE_3D_BINDING_EXT"
	_GLenum_map[32875] = "GL_PACK_SKIP_IMAGES"
	_GLenum_map[32875] = "GL_PACK_SKIP_IMAGES_EXT"
	_GLenum_map[32876] = "GL_PACK_IMAGE_HEIGHT"
	_GLenum_map[32876] = "GL_PACK_IMAGE_HEIGHT_EXT"
	_GLenum_map[32877] = "GL_UNPACK_SKIP_IMAGES_EXT"
	_GLenum_map[32877] = "GL_UNPACK_SKIP_IMAGES"
	_GLenum_map[32878] = "GL_UNPACK_IMAGE_HEIGHT"
	_GLenum_map[32878] = "GL_UNPACK_IMAGE_HEIGHT_EXT"
	_GLenum_map[32879] = "GL_TEXTURE_3D_OES"
	_GLenum_map[32879] = "GL_TEXTURE_3D"
	_GLenum_map[32879] = "GL_TEXTURE_3D_EXT"
	_GLenum_map[32880] = "GL_PROXY_TEXTURE_3D"
	_GLenum_map[32880] = "GL_PROXY_TEXTURE_3D_EXT"
	_GLenum_map[32881] = "GL_TEXTURE_DEPTH_EXT"
	_GLenum_map[32881] = "GL_TEXTURE_DEPTH"
	_GLenum_map[32882] = "GL_TEXTURE_WRAP_R"
	_GLenum_map[32882] = "GL_TEXTURE_WRAP_R_EXT"
	_GLenum_map[32882] = "GL_TEXTURE_WRAP_R_OES"
	_GLenum_map[32883] = "GL_MAX_3D_TEXTURE_SIZE_OES"
	_GLenum_map[32883] = "GL_MAX_3D_TEXTURE_SIZE"
	_GLenum_map[32883] = "GL_MAX_3D_TEXTURE_SIZE_EXT"
	_GLenum_map[32884] = "GL_VERTEX_ARRAY"
	_GLenum_map[32884] = "GL_VERTEX_ARRAY_KHR"
	_GLenum_map[32884] = "GL_VERTEX_ARRAY_EXT"
	_GLenum_map[32885] = "GL_NORMAL_ARRAY"
	_GLenum_map[32885] = "GL_NORMAL_ARRAY_EXT"
	_GLenum_map[32886] = "GL_COLOR_ARRAY"
	_GLenum_map[32886] = "GL_COLOR_ARRAY_EXT"
	_GLenum_map[32887] = "GL_INDEX_ARRAY_EXT"
	_GLenum_map[32887] = "GL_INDEX_ARRAY"
	_GLenum_map[32888] = "GL_TEXTURE_COORD_ARRAY_EXT"
	_GLenum_map[32888] = "GL_TEXTURE_COORD_ARRAY"
	_GLenum_map[32889] = "GL_EDGE_FLAG_ARRAY"
	_GLenum_map[32889] = "GL_EDGE_FLAG_ARRAY_EXT"
	_GLenum_map[32890] = "GL_VERTEX_ARRAY_SIZE"
	_GLenum_map[32890] = "GL_VERTEX_ARRAY_SIZE_EXT"
	_GLenum_map[32891] = "GL_VERTEX_ARRAY_TYPE"
	_GLenum_map[32891] = "GL_VERTEX_ARRAY_TYPE_EXT"
	_GLenum_map[32892] = "GL_VERTEX_ARRAY_STRIDE_EXT"
	_GLenum_map[32892] = "GL_VERTEX_ARRAY_STRIDE"
	_GLenum_map[32893] = "GL_VERTEX_ARRAY_COUNT_EXT"
	_GLenum_map[32894] = "GL_NORMAL_ARRAY_TYPE"
	_GLenum_map[32894] = "GL_NORMAL_ARRAY_TYPE_EXT"
	_GLenum_map[32895] = "GL_NORMAL_ARRAY_STRIDE"
	_GLenum_map[32895] = "GL_NORMAL_ARRAY_STRIDE_EXT"
	_GLenum_map[32896] = "GL_NORMAL_ARRAY_COUNT_EXT"
	_GLenum_map[32897] = "GL_COLOR_ARRAY_SIZE"
	_GLenum_map[32897] = "GL_COLOR_ARRAY_SIZE_EXT"
	_GLenum_map[32898] = "GL_COLOR_ARRAY_TYPE_EXT"
	_GLenum_map[32898] = "GL_COLOR_ARRAY_TYPE"
	_GLenum_map[32899] = "GL_COLOR_ARRAY_STRIDE_EXT"
	_GLenum_map[32899] = "GL_COLOR_ARRAY_STRIDE"
	_GLenum_map[32900] = "GL_COLOR_ARRAY_COUNT_EXT"
	_GLenum_map[32901] = "GL_INDEX_ARRAY_TYPE_EXT"
	_GLenum_map[32901] = "GL_INDEX_ARRAY_TYPE"
	_GLenum_map[32902] = "GL_INDEX_ARRAY_STRIDE"
	_GLenum_map[32902] = "GL_INDEX_ARRAY_STRIDE_EXT"
	_GLenum_map[32903] = "GL_INDEX_ARRAY_COUNT_EXT"
	_GLenum_map[32904] = "GL_TEXTURE_COORD_ARRAY_SIZE"
	_GLenum_map[32904] = "GL_TEXTURE_COORD_ARRAY_SIZE_EXT"
	_GLenum_map[32905] = "GL_TEXTURE_COORD_ARRAY_TYPE"
	_GLenum_map[32905] = "GL_TEXTURE_COORD_ARRAY_TYPE_EXT"
	_GLenum_map[32906] = "GL_TEXTURE_COORD_ARRAY_STRIDE"
	_GLenum_map[32906] = "GL_TEXTURE_COORD_ARRAY_STRIDE_EXT"
	_GLenum_map[32907] = "GL_TEXTURE_COORD_ARRAY_COUNT_EXT"
	_GLenum_map[32908] = "GL_EDGE_FLAG_ARRAY_STRIDE_EXT"
	_GLenum_map[32908] = "GL_EDGE_FLAG_ARRAY_STRIDE"
	_GLenum_map[32909] = "GL_EDGE_FLAG_ARRAY_COUNT_EXT"
	_GLenum_map[32910] = "GL_VERTEX_ARRAY_POINTER_EXT"
	_GLenum_map[32910] = "GL_VERTEX_ARRAY_POINTER"
	_GLenum_map[32911] = "GL_NORMAL_ARRAY_POINTER_EXT"
	_GLenum_map[32911] = "GL_NORMAL_ARRAY_POINTER"
	_GLenum_map[32912] = "GL_COLOR_ARRAY_POINTER"
	_GLenum_map[32912] = "GL_COLOR_ARRAY_POINTER_EXT"
	_GLenum_map[32913] = "GL_INDEX_ARRAY_POINTER"
	_GLenum_map[32913] = "GL_INDEX_ARRAY_POINTER_EXT"
	_GLenum_map[32914] = "GL_TEXTURE_COORD_ARRAY_POINTER"
	_GLenum_map[32914] = "GL_TEXTURE_COORD_ARRAY_POINTER_EXT"
	_GLenum_map[32915] = "GL_EDGE_FLAG_ARRAY_POINTER"
	_GLenum_map[32915] = "GL_EDGE_FLAG_ARRAY_POINTER_EXT"
	_GLenum_map[32916] = "GL_INTERLACE_SGIX"
	_GLenum_map[32917] = "GL_DETAIL_TEXTURE_2D_SGIS"
	_GLenum_map[32918] = "GL_DETAIL_TEXTURE_2D_BINDING_SGIS"
	_GLenum_map[32919] = "GL_LINEAR_DETAIL_SGIS"
	_GLenum_map[32920] = "GL_LINEAR_DETAIL_ALPHA_SGIS"
	_GLenum_map[32921] = "GL_LINEAR_DETAIL_COLOR_SGIS"
	_GLenum_map[32922] = "GL_DETAIL_TEXTURE_LEVEL_SGIS"
	_GLenum_map[32923] = "GL_DETAIL_TEXTURE_MODE_SGIS"
	_GLenum_map[32924] = "GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS"
	_GLenum_map[32925] = "GL_MULTISAMPLE_SGIS"
	_GLenum_map[32925] = "GL_MULTISAMPLE_EXT"
	_GLenum_map[32925] = "GL_MULTISAMPLE_ARB"
	_GLenum_map[32925] = "GL_MULTISAMPLE"
	_GLenum_map[32926] = "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB"
	_GLenum_map[32926] = "GL_SAMPLE_ALPHA_TO_MASK_SGIS"
	_GLenum_map[32926] = "GL_SAMPLE_ALPHA_TO_COVERAGE"
	_GLenum_map[32926] = "GL_SAMPLE_ALPHA_TO_MASK_EXT"
	_GLenum_map[32927] = "GL_SAMPLE_ALPHA_TO_ONE_EXT"
	_GLenum_map[32927] = "GL_SAMPLE_ALPHA_TO_ONE"
	_GLenum_map[32927] = "GL_SAMPLE_ALPHA_TO_ONE_ARB"
	_GLenum_map[32927] = "GL_SAMPLE_ALPHA_TO_ONE_SGIS"
	_GLenum_map[32928] = "GL_SAMPLE_MASK_EXT"
	_GLenum_map[32928] = "GL_SAMPLE_COVERAGE_ARB"
	_GLenum_map[32928] = "GL_SAMPLE_MASK_SGIS"
	_GLenum_map[32928] = "GL_SAMPLE_COVERAGE"
	_GLenum_map[32929] = "GL_1PASS_EXT"
	_GLenum_map[32929] = "GL_1PASS_SGIS"
	_GLenum_map[32930] = "GL_2PASS_0_SGIS"
	_GLenum_map[32930] = "GL_2PASS_0_EXT"
	_GLenum_map[32931] = "GL_2PASS_1_EXT"
	_GLenum_map[32931] = "GL_2PASS_1_SGIS"
	_GLenum_map[32932] = "GL_4PASS_0_EXT"
	_GLenum_map[32932] = "GL_4PASS_0_SGIS"
	_GLenum_map[32933] = "GL_4PASS_1_EXT"
	_GLenum_map[32933] = "GL_4PASS_1_SGIS"
	_GLenum_map[32934] = "GL_4PASS_2_SGIS"
	_GLenum_map[32934] = "GL_4PASS_2_EXT"
	_GLenum_map[32935] = "GL_4PASS_3_EXT"
	_GLenum_map[32935] = "GL_4PASS_3_SGIS"
	_GLenum_map[32936] = "GL_SAMPLE_BUFFERS_SGIS"
	_GLenum_map[32936] = "GL_SAMPLE_BUFFERS_ARB"
	_GLenum_map[32936] = "GL_SAMPLE_BUFFERS"
	_GLenum_map[32936] = "GL_SAMPLE_BUFFERS_EXT"
	_GLenum_map[32937] = "GL_SAMPLES_SGIS"
	_GLenum_map[32937] = "GL_SAMPLES_ARB"
	_GLenum_map[32937] = "GL_SAMPLES"
	_GLenum_map[32937] = "GL_SAMPLES_EXT"
	_GLenum_map[32938] = "GL_SAMPLE_COVERAGE_VALUE_ARB"
	_GLenum_map[32938] = "GL_SAMPLE_MASK_VALUE_SGIS"
	_GLenum_map[32938] = "GL_SAMPLE_MASK_VALUE_EXT"
	_GLenum_map[32938] = "GL_SAMPLE_COVERAGE_VALUE"
	_GLenum_map[32939] = "GL_SAMPLE_COVERAGE_INVERT"
	_GLenum_map[32939] = "GL_SAMPLE_MASK_INVERT_EXT"
	_GLenum_map[32939] = "GL_SAMPLE_COVERAGE_INVERT_ARB"
	_GLenum_map[32939] = "GL_SAMPLE_MASK_INVERT_SGIS"
	_GLenum_map[32940] = "GL_SAMPLE_PATTERN_EXT"
	_GLenum_map[32940] = "GL_SAMPLE_PATTERN_SGIS"
	_GLenum_map[32941] = "GL_LINEAR_SHARPEN_SGIS"
	_GLenum_map[32942] = "GL_LINEAR_SHARPEN_ALPHA_SGIS"
	_GLenum_map[32943] = "GL_LINEAR_SHARPEN_COLOR_SGIS"
	_GLenum_map[32944] = "GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS"
	_GLenum_map[32945] = "GL_COLOR_MATRIX"
	_GLenum_map[32945] = "GL_COLOR_MATRIX_SGI"
	_GLenum_map[32946] = "GL_COLOR_MATRIX_STACK_DEPTH"
	_GLenum_map[32946] = "GL_COLOR_MATRIX_STACK_DEPTH_SGI"
	_GLenum_map[32947] = "GL_MAX_COLOR_MATRIX_STACK_DEPTH"
	_GLenum_map[32947] = "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI"
	_GLenum_map[32948] = "GL_POST_COLOR_MATRIX_RED_SCALE_SGI"
	_GLenum_map[32948] = "GL_POST_COLOR_MATRIX_RED_SCALE"
	_GLenum_map[32949] = "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI"
	_GLenum_map[32949] = "GL_POST_COLOR_MATRIX_GREEN_SCALE"
	_GLenum_map[32950] = "GL_POST_COLOR_MATRIX_BLUE_SCALE"
	_GLenum_map[32950] = "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI"
	_GLenum_map[32951] = "GL_POST_COLOR_MATRIX_ALPHA_SCALE"
	_GLenum_map[32951] = "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI"
	_GLenum_map[32952] = "GL_POST_COLOR_MATRIX_RED_BIAS_SGI"
	_GLenum_map[32952] = "GL_POST_COLOR_MATRIX_RED_BIAS"
	_GLenum_map[32953] = "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI"
	_GLenum_map[32953] = "GL_POST_COLOR_MATRIX_GREEN_BIAS"
	_GLenum_map[32954] = "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI"
	_GLenum_map[32954] = "GL_POST_COLOR_MATRIX_BLUE_BIAS"
	_GLenum_map[32955] = "GL_POST_COLOR_MATRIX_ALPHA_BIAS"
	_GLenum_map[32955] = "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI"
	_GLenum_map[32956] = "GL_TEXTURE_COLOR_TABLE_SGI"
	_GLenum_map[32957] = "GL_PROXY_TEXTURE_COLOR_TABLE_SGI"
	_GLenum_map[32958] = "GL_TEXTURE_ENV_BIAS_SGIX"
	_GLenum_map[32959] = "GL_SHADOW_AMBIENT_SGIX"
	_GLenum_map[32959] = "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB"
	_GLenum_map[32968] = "GL_BLEND_DST_RGB_OES"
	_GLenum_map[32968] = "GL_BLEND_DST_RGB"
	_GLenum_map[32968] = "GL_BLEND_DST_RGB_EXT"
	_GLenum_map[32969] = "GL_BLEND_SRC_RGB"
	_GLenum_map[32969] = "GL_BLEND_SRC_RGB_EXT"
	_GLenum_map[32969] = "GL_BLEND_SRC_RGB_OES"
	_GLenum_map[32970] = "GL_BLEND_DST_ALPHA"
	_GLenum_map[32970] = "GL_BLEND_DST_ALPHA_EXT"
	_GLenum_map[32970] = "GL_BLEND_DST_ALPHA_OES"
	_GLenum_map[32971] = "GL_BLEND_SRC_ALPHA_OES"
	_GLenum_map[32971] = "GL_BLEND_SRC_ALPHA"
	_GLenum_map[32971] = "GL_BLEND_SRC_ALPHA_EXT"
	_GLenum_map[32972] = "GL_422_EXT"
	_GLenum_map[32973] = "GL_422_REV_EXT"
	_GLenum_map[32974] = "GL_422_AVERAGE_EXT"
	_GLenum_map[32975] = "GL_422_REV_AVERAGE_EXT"
	_GLenum_map[32976] = "GL_COLOR_TABLE"
	_GLenum_map[32976] = "GL_COLOR_TABLE_SGI"
	_GLenum_map[32977] = "GL_POST_CONVOLUTION_COLOR_TABLE"
	_GLenum_map[32977] = "GL_POST_CONVOLUTION_COLOR_TABLE_SGI"
	_GLenum_map[32978] = "GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI"
	_GLenum_map[32978] = "GL_POST_COLOR_MATRIX_COLOR_TABLE"
	_GLenum_map[32979] = "GL_PROXY_COLOR_TABLE"
	_GLenum_map[32979] = "GL_PROXY_COLOR_TABLE_SGI"
	_GLenum_map[32980] = "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI"
	_GLenum_map[32980] = "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE"
	_GLenum_map[32981] = "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE"
	_GLenum_map[32981] = "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI"
	_GLenum_map[32982] = "GL_COLOR_TABLE_SCALE_SGI"
	_GLenum_map[32982] = "GL_COLOR_TABLE_SCALE"
	_GLenum_map[32983] = "GL_COLOR_TABLE_BIAS_SGI"
	_GLenum_map[32983] = "GL_COLOR_TABLE_BIAS"
	_GLenum_map[32984] = "GL_COLOR_TABLE_FORMAT"
	_GLenum_map[32984] = "GL_COLOR_TABLE_FORMAT_SGI"
	_GLenum_map[32985] = "GL_COLOR_TABLE_WIDTH"
	_GLenum_map[32985] = "GL_COLOR_TABLE_WIDTH_SGI"
	_GLenum_map[32986] = "GL_COLOR_TABLE_RED_SIZE_SGI"
	_GLenum_map[32986] = "GL_COLOR_TABLE_RED_SIZE"
	_GLenum_map[32987] = "GL_COLOR_TABLE_GREEN_SIZE_SGI"
	_GLenum_map[32987] = "GL_COLOR_TABLE_GREEN_SIZE"
	_GLenum_map[32988] = "GL_COLOR_TABLE_BLUE_SIZE_SGI"
	_GLenum_map[32988] = "GL_COLOR_TABLE_BLUE_SIZE"
	_GLenum_map[32989] = "GL_COLOR_TABLE_ALPHA_SIZE"
	_GLenum_map[32989] = "GL_COLOR_TABLE_ALPHA_SIZE_SGI"
	_GLenum_map[32990] = "GL_COLOR_TABLE_LUMINANCE_SIZE_SGI"
	_GLenum_map[32990] = "GL_COLOR_TABLE_LUMINANCE_SIZE"
	_GLenum_map[32991] = "GL_COLOR_TABLE_INTENSITY_SIZE_SGI"
	_GLenum_map[32991] = "GL_COLOR_TABLE_INTENSITY_SIZE"
	_GLenum_map[32992] = "GL_BGR"
	_GLenum_map[32992] = "GL_BGR_EXT"
	_GLenum_map[32993] = "GL_BGRA_IMG"
	_GLenum_map[32993] = "GL_BGRA"
	_GLenum_map[32993] = "GL_BGRA_EXT"
	_GLenum_map[32994] = "GL_COLOR_INDEX1_EXT"
	_GLenum_map[32995] = "GL_COLOR_INDEX2_EXT"
	_GLenum_map[32996] = "GL_COLOR_INDEX4_EXT"
	_GLenum_map[32997] = "GL_COLOR_INDEX8_EXT"
	_GLenum_map[32998] = "GL_COLOR_INDEX12_EXT"
	_GLenum_map[32999] = "GL_COLOR_INDEX16_EXT"
	_GLenum_map[33000] = "GL_MAX_ELEMENTS_VERTICES"
	_GLenum_map[33000] = "GL_MAX_ELEMENTS_VERTICES_EXT"
	_GLenum_map[33001] = "GL_MAX_ELEMENTS_INDICES_EXT"
	_GLenum_map[33001] = "GL_MAX_ELEMENTS_INDICES"
	_GLenum_map[33002] = "GL_PHONG_WIN"
	_GLenum_map[33003] = "GL_PHONG_HINT_WIN"
	_GLenum_map[33004] = "GL_FOG_SPECULAR_TEXTURE_WIN"
	_GLenum_map[33005] = "GL_TEXTURE_INDEX_SIZE_EXT"
	_GLenum_map[33006] = "GL_PARAMETER_BUFFER_ARB"
	_GLenum_map[33007] = "GL_PARAMETER_BUFFER_BINDING_ARB"
	_GLenum_map[33008] = "GL_CLIP_VOLUME_CLIPPING_HINT_EXT"
	_GLenum_map[33040] = "GL_DUAL_ALPHA4_SGIS"
	_GLenum_map[33041] = "GL_DUAL_ALPHA8_SGIS"
	_GLenum_map[33042] = "GL_DUAL_ALPHA12_SGIS"
	_GLenum_map[33043] = "GL_DUAL_ALPHA16_SGIS"
	_GLenum_map[33044] = "GL_DUAL_LUMINANCE4_SGIS"
	_GLenum_map[33045] = "GL_DUAL_LUMINANCE8_SGIS"
	_GLenum_map[33046] = "GL_DUAL_LUMINANCE12_SGIS"
	_GLenum_map[33047] = "GL_DUAL_LUMINANCE16_SGIS"
	_GLenum_map[33048] = "GL_DUAL_INTENSITY4_SGIS"
	_GLenum_map[33049] = "GL_DUAL_INTENSITY8_SGIS"
	_GLenum_map[33050] = "GL_DUAL_INTENSITY12_SGIS"
	_GLenum_map[33051] = "GL_DUAL_INTENSITY16_SGIS"
	_GLenum_map[33052] = "GL_DUAL_LUMINANCE_ALPHA4_SGIS"
	_GLenum_map[33053] = "GL_DUAL_LUMINANCE_ALPHA8_SGIS"
	_GLenum_map[33054] = "GL_QUAD_ALPHA4_SGIS"
	_GLenum_map[33055] = "GL_QUAD_ALPHA8_SGIS"
	_GLenum_map[33056] = "GL_QUAD_LUMINANCE4_SGIS"
	_GLenum_map[33057] = "GL_QUAD_LUMINANCE8_SGIS"
	_GLenum_map[33058] = "GL_QUAD_INTENSITY4_SGIS"
	_GLenum_map[33059] = "GL_QUAD_INTENSITY8_SGIS"
	_GLenum_map[33060] = "GL_DUAL_TEXTURE_SELECT_SGIS"
	_GLenum_map[33061] = "GL_QUAD_TEXTURE_SELECT_SGIS"
	_GLenum_map[33062] = "GL_POINT_SIZE_MIN_EXT"
	_GLenum_map[33062] = "GL_POINT_SIZE_MIN_ARB"
	_GLenum_map[33062] = "GL_POINT_SIZE_MIN"
	_GLenum_map[33062] = "GL_POINT_SIZE_MIN_SGIS"
	_GLenum_map[33063] = "GL_POINT_SIZE_MAX_ARB"
	_GLenum_map[33063] = "GL_POINT_SIZE_MAX_EXT"
	_GLenum_map[33063] = "GL_POINT_SIZE_MAX"
	_GLenum_map[33063] = "GL_POINT_SIZE_MAX_SGIS"
	_GLenum_map[33064] = "GL_POINT_FADE_THRESHOLD_SIZE"
	_GLenum_map[33064] = "GL_POINT_FADE_THRESHOLD_SIZE_EXT"
	_GLenum_map[33064] = "GL_POINT_FADE_THRESHOLD_SIZE_ARB"
	_GLenum_map[33064] = "GL_POINT_FADE_THRESHOLD_SIZE_SGIS"
	_GLenum_map[33065] = "GL_POINT_DISTANCE_ATTENUATION_ARB"
	_GLenum_map[33065] = "GL_POINT_DISTANCE_ATTENUATION"
	_GLenum_map[33065] = "GL_DISTANCE_ATTENUATION_SGIS"
	_GLenum_map[33065] = "GL_DISTANCE_ATTENUATION_EXT"
	_GLenum_map[33066] = "GL_FOG_FUNC_SGIS"
	_GLenum_map[33067] = "GL_FOG_FUNC_POINTS_SGIS"
	_GLenum_map[33068] = "GL_MAX_FOG_FUNC_POINTS_SGIS"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER_ARB"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER_EXT"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER_NV"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER_OES"
	_GLenum_map[33069] = "GL_CLAMP_TO_BORDER_SGIS"
	_GLenum_map[33070] = "GL_TEXTURE_MULTI_BUFFER_HINT_SGIX"
	_GLenum_map[33071] = "GL_CLAMP_TO_EDGE"
	_GLenum_map[33071] = "GL_CLAMP_TO_EDGE_SGIS"
	_GLenum_map[33072] = "GL_PACK_SKIP_VOLUMES_SGIS"
	_GLenum_map[33073] = "GL_PACK_IMAGE_DEPTH_SGIS"
	_GLenum_map[33074] = "GL_UNPACK_SKIP_VOLUMES_SGIS"
	_GLenum_map[33075] = "GL_UNPACK_IMAGE_DEPTH_SGIS"
	_GLenum_map[33076] = "GL_TEXTURE_4D_SGIS"
	_GLenum_map[33077] = "GL_PROXY_TEXTURE_4D_SGIS"
	_GLenum_map[33078] = "GL_TEXTURE_4DSIZE_SGIS"
	_GLenum_map[33079] = "GL_TEXTURE_WRAP_Q_SGIS"
	_GLenum_map[33080] = "GL_MAX_4D_TEXTURE_SIZE_SGIS"
	_GLenum_map[33081] = "GL_PIXEL_TEX_GEN_SGIX"
	_GLenum_map[33082] = "GL_TEXTURE_MIN_LOD"
	_GLenum_map[33082] = "GL_TEXTURE_MIN_LOD_SGIS"
	_GLenum_map[33083] = "GL_TEXTURE_MAX_LOD"
	_GLenum_map[33083] = "GL_TEXTURE_MAX_LOD_SGIS"
	_GLenum_map[33084] = "GL_TEXTURE_BASE_LEVEL_SGIS"
	_GLenum_map[33084] = "GL_TEXTURE_BASE_LEVEL"
	_GLenum_map[33085] = "GL_TEXTURE_MAX_LEVEL"
	_GLenum_map[33085] = "GL_TEXTURE_MAX_LEVEL_SGIS"
	_GLenum_map[33085] = "GL_TEXTURE_MAX_LEVEL_APPLE"
	_GLenum_map[33086] = "GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX"
	_GLenum_map[33087] = "GL_PIXEL_TILE_CACHE_INCREMENT_SGIX"
	_GLenum_map[33088] = "GL_PIXEL_TILE_WIDTH_SGIX"
	_GLenum_map[33089] = "GL_PIXEL_TILE_HEIGHT_SGIX"
	_GLenum_map[33090] = "GL_PIXEL_TILE_GRID_WIDTH_SGIX"
	_GLenum_map[33091] = "GL_PIXEL_TILE_GRID_HEIGHT_SGIX"
	_GLenum_map[33092] = "GL_PIXEL_TILE_GRID_DEPTH_SGIX"
	_GLenum_map[33093] = "GL_PIXEL_TILE_CACHE_SIZE_SGIX"
	_GLenum_map[33094] = "GL_FILTER4_SGIS"
	_GLenum_map[33095] = "GL_TEXTURE_FILTER4_SIZE_SGIS"
	_GLenum_map[33096] = "GL_SPRITE_SGIX"
	_GLenum_map[33097] = "GL_SPRITE_MODE_SGIX"
	_GLenum_map[33098] = "GL_SPRITE_AXIS_SGIX"
	_GLenum_map[33099] = "GL_SPRITE_TRANSLATION_SGIX"
	_GLenum_map[33100] = "GL_SPRITE_AXIAL_SGIX"
	_GLenum_map[33101] = "GL_SPRITE_OBJECT_ALIGNED_SGIX"
	_GLenum_map[33102] = "GL_SPRITE_EYE_ALIGNED_SGIX"
	_GLenum_map[33103] = "GL_TEXTURE_4D_BINDING_SGIS"
	_GLenum_map[33104] = "GL_IGNORE_BORDER_HP"
	_GLenum_map[33105] = "GL_CONSTANT_BORDER"
	_GLenum_map[33105] = "GL_CONSTANT_BORDER_HP"
	_GLenum_map[33107] = "GL_REPLICATE_BORDER"
	_GLenum_map[33107] = "GL_REPLICATE_BORDER_HP"
	_GLenum_map[33108] = "GL_CONVOLUTION_BORDER_COLOR"
	_GLenum_map[33108] = "GL_CONVOLUTION_BORDER_COLOR_HP"
	_GLenum_map[33109] = "GL_IMAGE_SCALE_X_HP"
	_GLenum_map[33110] = "GL_IMAGE_SCALE_Y_HP"
	_GLenum_map[33111] = "GL_IMAGE_TRANSLATE_X_HP"
	_GLenum_map[33112] = "GL_IMAGE_TRANSLATE_Y_HP"
	_GLenum_map[33113] = "GL_IMAGE_ROTATE_ANGLE_HP"
	_GLenum_map[33114] = "GL_IMAGE_ROTATE_ORIGIN_X_HP"
	_GLenum_map[33115] = "GL_IMAGE_ROTATE_ORIGIN_Y_HP"
	_GLenum_map[33116] = "GL_IMAGE_MAG_FILTER_HP"
	_GLenum_map[33117] = "GL_IMAGE_MIN_FILTER_HP"
	_GLenum_map[33118] = "GL_IMAGE_CUBIC_WEIGHT_HP"
	_GLenum_map[33119] = "GL_CUBIC_HP"
	_GLenum_map[33120] = "GL_AVERAGE_HP"
	_GLenum_map[33121] = "GL_IMAGE_TRANSFORM_2D_HP"
	_GLenum_map[33122] = "GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP"
	_GLenum_map[33123] = "GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP"
	_GLenum_map[33125] = "GL_OCCLUSION_TEST_HP"
	_GLenum_map[33126] = "GL_OCCLUSION_TEST_RESULT_HP"
	_GLenum_map[33127] = "GL_TEXTURE_LIGHTING_MODE_HP"
	_GLenum_map[33128] = "GL_TEXTURE_POST_SPECULAR_HP"
	_GLenum_map[33129] = "GL_TEXTURE_PRE_SPECULAR_HP"
	_GLenum_map[33136] = "GL_LINEAR_CLIPMAP_LINEAR_SGIX"
	_GLenum_map[33137] = "GL_TEXTURE_CLIPMAP_CENTER_SGIX"
	_GLenum_map[33138] = "GL_TEXTURE_CLIPMAP_FRAME_SGIX"
	_GLenum_map[33139] = "GL_TEXTURE_CLIPMAP_OFFSET_SGIX"
	_GLenum_map[33140] = "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX"
	_GLenum_map[33141] = "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX"
	_GLenum_map[33142] = "GL_TEXTURE_CLIPMAP_DEPTH_SGIX"
	_GLenum_map[33143] = "GL_MAX_CLIPMAP_DEPTH_SGIX"
	_GLenum_map[33144] = "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX"
	_GLenum_map[33145] = "GL_POST_TEXTURE_FILTER_BIAS_SGIX"
	_GLenum_map[33146] = "GL_POST_TEXTURE_FILTER_SCALE_SGIX"
	_GLenum_map[33147] = "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX"
	_GLenum_map[33148] = "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX"
	_GLenum_map[33149] = "GL_REFERENCE_PLANE_SGIX"
	_GLenum_map[33150] = "GL_REFERENCE_PLANE_EQUATION_SGIX"
	_GLenum_map[33151] = "GL_IR_INSTRUMENT1_SGIX"
	_GLenum_map[33152] = "GL_INSTRUMENT_BUFFER_POINTER_SGIX"
	_GLenum_map[33153] = "GL_INSTRUMENT_MEASUREMENTS_SGIX"
	_GLenum_map[33154] = "GL_LIST_PRIORITY_SGIX"
	_GLenum_map[33155] = "GL_CALLIGRAPHIC_FRAGMENT_SGIX"
	_GLenum_map[33156] = "GL_PIXEL_TEX_GEN_Q_CEILING_SGIX"
	_GLenum_map[33157] = "GL_PIXEL_TEX_GEN_Q_ROUND_SGIX"
	_GLenum_map[33158] = "GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX"
	_GLenum_map[33159] = "GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX"
	_GLenum_map[33160] = "GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX"
	_GLenum_map[33161] = "GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX"
	_GLenum_map[33162] = "GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX"
	_GLenum_map[33163] = "GL_FRAMEZOOM_SGIX"
	_GLenum_map[33164] = "GL_FRAMEZOOM_FACTOR_SGIX"
	_GLenum_map[33165] = "GL_MAX_FRAMEZOOM_FACTOR_SGIX"
	_GLenum_map[33166] = "GL_TEXTURE_LOD_BIAS_S_SGIX"
	_GLenum_map[33167] = "GL_TEXTURE_LOD_BIAS_T_SGIX"
	_GLenum_map[33168] = "GL_TEXTURE_LOD_BIAS_R_SGIX"
	_GLenum_map[33169] = "GL_GENERATE_MIPMAP_SGIS"
	_GLenum_map[33169] = "GL_GENERATE_MIPMAP"
	_GLenum_map[33170] = "GL_GENERATE_MIPMAP_HINT"
	_GLenum_map[33170] = "GL_GENERATE_MIPMAP_HINT_SGIS"
	_GLenum_map[33172] = "GL_GEOMETRY_DEFORMATION_SGIX"
	_GLenum_map[33173] = "GL_TEXTURE_DEFORMATION_SGIX"
	_GLenum_map[33174] = "GL_DEFORMATIONS_MASK_SGIX"
	_GLenum_map[33175] = "GL_MAX_DEFORMATION_ORDER_SGIX"
	_GLenum_map[33176] = "GL_FOG_OFFSET_SGIX"
	_GLenum_map[33177] = "GL_FOG_OFFSET_VALUE_SGIX"
	_GLenum_map[33178] = "GL_TEXTURE_COMPARE_SGIX"
	_GLenum_map[33179] = "GL_TEXTURE_COMPARE_OPERATOR_SGIX"
	_GLenum_map[33180] = "GL_TEXTURE_LEQUAL_R_SGIX"
	_GLenum_map[33181] = "GL_TEXTURE_GEQUAL_R_SGIX"
	_GLenum_map[33189] = "GL_DEPTH_COMPONENT16_SGIX"
	_GLenum_map[33189] = "GL_DEPTH_COMPONENT16_ARB"
	_GLenum_map[33189] = "GL_DEPTH_COMPONENT16"
	_GLenum_map[33189] = "GL_DEPTH_COMPONENT16_OES"
	_GLenum_map[33190] = "GL_DEPTH_COMPONENT24_OES"
	_GLenum_map[33190] = "GL_DEPTH_COMPONENT24_SGIX"
	_GLenum_map[33190] = "GL_DEPTH_COMPONENT24"
	_GLenum_map[33190] = "GL_DEPTH_COMPONENT24_ARB"
	_GLenum_map[33191] = "GL_DEPTH_COMPONENT32_SGIX"
	_GLenum_map[33191] = "GL_DEPTH_COMPONENT32_OES"
	_GLenum_map[33191] = "GL_DEPTH_COMPONENT32_ARB"
	_GLenum_map[33191] = "GL_DEPTH_COMPONENT32"
	_GLenum_map[33192] = "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT"
	_GLenum_map[33193] = "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT"
	_GLenum_map[33194] = "GL_CULL_VERTEX_EXT"
	_GLenum_map[33195] = "GL_CULL_VERTEX_EYE_POSITION_EXT"
	_GLenum_map[33196] = "GL_CULL_VERTEX_OBJECT_POSITION_EXT"
	_GLenum_map[33197] = "GL_IUI_V2F_EXT"
	_GLenum_map[33198] = "GL_IUI_V3F_EXT"
	_GLenum_map[33199] = "GL_IUI_N3F_V2F_EXT"
	_GLenum_map[33200] = "GL_IUI_N3F_V3F_EXT"
	_GLenum_map[33201] = "GL_T2F_IUI_V2F_EXT"
	_GLenum_map[33202] = "GL_T2F_IUI_V3F_EXT"
	_GLenum_map[33203] = "GL_T2F_IUI_N3F_V2F_EXT"
	_GLenum_map[33204] = "GL_T2F_IUI_N3F_V3F_EXT"
	_GLenum_map[33205] = "GL_INDEX_TEST_EXT"
	_GLenum_map[33206] = "GL_INDEX_TEST_FUNC_EXT"
	_GLenum_map[33207] = "GL_INDEX_TEST_REF_EXT"
	_GLenum_map[33208] = "GL_INDEX_MATERIAL_EXT"
	_GLenum_map[33209] = "GL_INDEX_MATERIAL_PARAMETER_EXT"
	_GLenum_map[33210] = "GL_INDEX_MATERIAL_FACE_EXT"
	_GLenum_map[33211] = "GL_YCRCB_422_SGIX"
	_GLenum_map[33212] = "GL_YCRCB_444_SGIX"
	_GLenum_map[33236] = "GL_WRAP_BORDER_SUN"
	_GLenum_map[33237] = "GL_UNPACK_CONSTANT_DATA_SUNX"
	_GLenum_map[33238] = "GL_TEXTURE_CONSTANT_DATA_SUNX"
	_GLenum_map[33239] = "GL_TRIANGLE_LIST_SUN"
	_GLenum_map[33240] = "GL_REPLACEMENT_CODE_SUN"
	_GLenum_map[33241] = "GL_GLOBAL_ALPHA_SUN"
	_GLenum_map[33242] = "GL_GLOBAL_ALPHA_FACTOR_SUN"
	_GLenum_map[33263] = "GL_TEXTURE_COLOR_WRITEMASK_SGIS"
	_GLenum_map[33264] = "GL_EYE_DISTANCE_TO_POINT_SGIS"
	_GLenum_map[33265] = "GL_OBJECT_DISTANCE_TO_POINT_SGIS"
	_GLenum_map[33266] = "GL_EYE_DISTANCE_TO_LINE_SGIS"
	_GLenum_map[33267] = "GL_OBJECT_DISTANCE_TO_LINE_SGIS"
	_GLenum_map[33268] = "GL_EYE_POINT_SGIS"
	_GLenum_map[33269] = "GL_OBJECT_POINT_SGIS"
	_GLenum_map[33270] = "GL_EYE_LINE_SGIS"
	_GLenum_map[33271] = "GL_OBJECT_LINE_SGIS"
	_GLenum_map[33272] = "GL_LIGHT_MODEL_COLOR_CONTROL"
	_GLenum_map[33272] = "GL_LIGHT_MODEL_COLOR_CONTROL_EXT"
	_GLenum_map[33273] = "GL_SINGLE_COLOR"
	_GLenum_map[33273] = "GL_SINGLE_COLOR_EXT"
	_GLenum_map[33274] = "GL_SEPARATE_SPECULAR_COLOR"
	_GLenum_map[33274] = "GL_SEPARATE_SPECULAR_COLOR_EXT"
	_GLenum_map[33275] = "GL_SHARED_TEXTURE_PALETTE_EXT"
	_GLenum_map[33280] = "GL_TEXT_FRAGMENT_SHADER_ATI"
	_GLenum_map[33296] = "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"
	_GLenum_map[33296] = "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT"
	_GLenum_map[33297] = "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"
	_GLenum_map[33297] = "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT"
	_GLenum_map[33298] = "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"
	_GLenum_map[33299] = "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"
	_GLenum_map[33300] = "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"
	_GLenum_map[33301] = "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"
	_GLenum_map[33302] = "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"
	_GLenum_map[33303] = "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"
	_GLenum_map[33304] = "GL_FRAMEBUFFER_DEFAULT"
	_GLenum_map[33305] = "GL_FRAMEBUFFER_UNDEFINED"
	_GLenum_map[33305] = "GL_FRAMEBUFFER_UNDEFINED_OES"
	_GLenum_map[33306] = "GL_DEPTH_STENCIL_ATTACHMENT"
	_GLenum_map[33307] = "GL_MAJOR_VERSION"
	_GLenum_map[33308] = "GL_MINOR_VERSION"
	_GLenum_map[33309] = "GL_NUM_EXTENSIONS"
	_GLenum_map[33310] = "GL_CONTEXT_FLAGS"
	_GLenum_map[33311] = "GL_BUFFER_IMMUTABLE_STORAGE_EXT"
	_GLenum_map[33311] = "GL_BUFFER_IMMUTABLE_STORAGE"
	_GLenum_map[33312] = "GL_BUFFER_STORAGE_FLAGS_EXT"
	_GLenum_map[33312] = "GL_BUFFER_STORAGE_FLAGS"
	_GLenum_map[33313] = "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED"
	_GLenum_map[33313] = "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES"
	_GLenum_map[33314] = "GL_INDEX"
	_GLenum_map[33317] = "GL_COMPRESSED_RED"
	_GLenum_map[33318] = "GL_COMPRESSED_RG"
	_GLenum_map[33319] = "GL_RG"
	_GLenum_map[33319] = "GL_RG_EXT"
	_GLenum_map[33320] = "GL_RG_INTEGER"
	_GLenum_map[33321] = "GL_R8"
	_GLenum_map[33321] = "GL_R8_EXT"
	_GLenum_map[33322] = "GL_R16"
	_GLenum_map[33322] = "GL_R16_EXT"
	_GLenum_map[33323] = "GL_RG8_EXT"
	_GLenum_map[33323] = "GL_RG8"
	_GLenum_map[33324] = "GL_RG16_EXT"
	_GLenum_map[33324] = "GL_RG16"
	_GLenum_map[33325] = "GL_R16F_EXT"
	_GLenum_map[33325] = "GL_R16F"
	_GLenum_map[33326] = "GL_R32F_EXT"
	_GLenum_map[33326] = "GL_R32F"
	_GLenum_map[33327] = "GL_RG16F"
	_GLenum_map[33327] = "GL_RG16F_EXT"
	_GLenum_map[33328] = "GL_RG32F_EXT"
	_GLenum_map[33328] = "GL_RG32F"
	_GLenum_map[33329] = "GL_R8I"
	_GLenum_map[33330] = "GL_R8UI"
	_GLenum_map[33331] = "GL_R16I"
	_GLenum_map[33332] = "GL_R16UI"
	_GLenum_map[33333] = "GL_R32I"
	_GLenum_map[33334] = "GL_R32UI"
	_GLenum_map[33335] = "GL_RG8I"
	_GLenum_map[33336] = "GL_RG8UI"
	_GLenum_map[33337] = "GL_RG16I"
	_GLenum_map[33338] = "GL_RG16UI"
	_GLenum_map[33339] = "GL_RG32I"
	_GLenum_map[33340] = "GL_RG32UI"
	_GLenum_map[33344] = "GL_SYNC_CL_EVENT_ARB"
	_GLenum_map[33345] = "GL_SYNC_CL_EVENT_COMPLETE_ARB"
	_GLenum_map[33346] = "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR"
	_GLenum_map[33346] = "GL_DEBUG_OUTPUT_SYNCHRONOUS"
	_GLenum_map[33346] = "GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB"
	_GLenum_map[33347] = "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR"
	_GLenum_map[33347] = "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH"
	_GLenum_map[33347] = "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB"
	_GLenum_map[33348] = "GL_DEBUG_CALLBACK_FUNCTION_KHR"
	_GLenum_map[33348] = "GL_DEBUG_CALLBACK_FUNCTION"
	_GLenum_map[33348] = "GL_DEBUG_CALLBACK_FUNCTION_ARB"
	_GLenum_map[33349] = "GL_DEBUG_CALLBACK_USER_PARAM_ARB"
	_GLenum_map[33349] = "GL_DEBUG_CALLBACK_USER_PARAM"
	_GLenum_map[33349] = "GL_DEBUG_CALLBACK_USER_PARAM_KHR"
	_GLenum_map[33350] = "GL_DEBUG_SOURCE_API"
	_GLenum_map[33350] = "GL_DEBUG_SOURCE_API_KHR"
	_GLenum_map[33350] = "GL_DEBUG_SOURCE_API_ARB"
	_GLenum_map[33351] = "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR"
	_GLenum_map[33351] = "GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB"
	_GLenum_map[33351] = "GL_DEBUG_SOURCE_WINDOW_SYSTEM"
	_GLenum_map[33352] = "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR"
	_GLenum_map[33352] = "GL_DEBUG_SOURCE_SHADER_COMPILER_ARB"
	_GLenum_map[33352] = "GL_DEBUG_SOURCE_SHADER_COMPILER"
	_GLenum_map[33353] = "GL_DEBUG_SOURCE_THIRD_PARTY_ARB"
	_GLenum_map[33353] = "GL_DEBUG_SOURCE_THIRD_PARTY"
	_GLenum_map[33353] = "GL_DEBUG_SOURCE_THIRD_PARTY_KHR"
	_GLenum_map[33354] = "GL_DEBUG_SOURCE_APPLICATION_KHR"
	_GLenum_map[33354] = "GL_DEBUG_SOURCE_APPLICATION"
	_GLenum_map[33354] = "GL_DEBUG_SOURCE_APPLICATION_ARB"
	_GLenum_map[33355] = "GL_DEBUG_SOURCE_OTHER_ARB"
	_GLenum_map[33355] = "GL_DEBUG_SOURCE_OTHER"
	_GLenum_map[33355] = "GL_DEBUG_SOURCE_OTHER_KHR"
	_GLenum_map[33356] = "GL_DEBUG_TYPE_ERROR_ARB"
	_GLenum_map[33356] = "GL_DEBUG_TYPE_ERROR"
	_GLenum_map[33356] = "GL_DEBUG_TYPE_ERROR_KHR"
	_GLenum_map[33357] = "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB"
	_GLenum_map[33357] = "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR"
	_GLenum_map[33357] = "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"
	_GLenum_map[33358] = "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB"
	_GLenum_map[33358] = "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR"
	_GLenum_map[33358] = "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"
	_GLenum_map[33359] = "GL_DEBUG_TYPE_PORTABILITY_ARB"
	_GLenum_map[33359] = "GL_DEBUG_TYPE_PORTABILITY"
	_GLenum_map[33359] = "GL_DEBUG_TYPE_PORTABILITY_KHR"
	_GLenum_map[33360] = "GL_DEBUG_TYPE_PERFORMANCE"
	_GLenum_map[33360] = "GL_DEBUG_TYPE_PERFORMANCE_KHR"
	_GLenum_map[33360] = "GL_DEBUG_TYPE_PERFORMANCE_ARB"
	_GLenum_map[33361] = "GL_DEBUG_TYPE_OTHER_ARB"
	_GLenum_map[33361] = "GL_DEBUG_TYPE_OTHER"
	_GLenum_map[33361] = "GL_DEBUG_TYPE_OTHER_KHR"
	_GLenum_map[33362] = "GL_LOSE_CONTEXT_ON_RESET_ARB"
	_GLenum_map[33362] = "GL_LOSE_CONTEXT_ON_RESET"
	_GLenum_map[33362] = "GL_LOSE_CONTEXT_ON_RESET_EXT"
	_GLenum_map[33362] = "GL_LOSE_CONTEXT_ON_RESET_KHR"
	_GLenum_map[33363] = "GL_GUILTY_CONTEXT_RESET_EXT"
	_GLenum_map[33363] = "GL_GUILTY_CONTEXT_RESET_ARB"
	_GLenum_map[33363] = "GL_GUILTY_CONTEXT_RESET_KHR"
	_GLenum_map[33363] = "GL_GUILTY_CONTEXT_RESET"
	_GLenum_map[33364] = "GL_INNOCENT_CONTEXT_RESET_EXT"
	_GLenum_map[33364] = "GL_INNOCENT_CONTEXT_RESET_KHR"
	_GLenum_map[33364] = "GL_INNOCENT_CONTEXT_RESET_ARB"
	_GLenum_map[33364] = "GL_INNOCENT_CONTEXT_RESET"
	_GLenum_map[33365] = "GL_UNKNOWN_CONTEXT_RESET"
	_GLenum_map[33365] = "GL_UNKNOWN_CONTEXT_RESET_KHR"
	_GLenum_map[33365] = "GL_UNKNOWN_CONTEXT_RESET_ARB"
	_GLenum_map[33365] = "GL_UNKNOWN_CONTEXT_RESET_EXT"
	_GLenum_map[33366] = "GL_RESET_NOTIFICATION_STRATEGY_KHR"
	_GLenum_map[33366] = "GL_RESET_NOTIFICATION_STRATEGY"
	_GLenum_map[33366] = "GL_RESET_NOTIFICATION_STRATEGY_EXT"
	_GLenum_map[33366] = "GL_RESET_NOTIFICATION_STRATEGY_ARB"
	_GLenum_map[33367] = "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"
	_GLenum_map[33368] = "GL_PROGRAM_SEPARABLE_EXT"
	_GLenum_map[33368] = "GL_PROGRAM_SEPARABLE"
	_GLenum_map[33369] = "GL_ACTIVE_PROGRAM"
	_GLenum_map[33369] = "GL_ACTIVE_PROGRAM_EXT"
	_GLenum_map[33370] = "GL_PROGRAM_PIPELINE_BINDING"
	_GLenum_map[33370] = "GL_PROGRAM_PIPELINE_BINDING_EXT"
	_GLenum_map[33371] = "GL_MAX_VIEWPORTS_NV"
	_GLenum_map[33371] = "GL_MAX_VIEWPORTS"
	_GLenum_map[33372] = "GL_VIEWPORT_SUBPIXEL_BITS_EXT"
	_GLenum_map[33372] = "GL_VIEWPORT_SUBPIXEL_BITS_NV"
	_GLenum_map[33372] = "GL_VIEWPORT_SUBPIXEL_BITS"
	_GLenum_map[33373] = "GL_VIEWPORT_BOUNDS_RANGE"
	_GLenum_map[33373] = "GL_VIEWPORT_BOUNDS_RANGE_NV"
	_GLenum_map[33373] = "GL_VIEWPORT_BOUNDS_RANGE_EXT"
	_GLenum_map[33374] = "GL_LAYER_PROVOKING_VERTEX"
	_GLenum_map[33374] = "GL_LAYER_PROVOKING_VERTEX_EXT"
	_GLenum_map[33374] = "GL_LAYER_PROVOKING_VERTEX_OES"
	_GLenum_map[33375] = "GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV"
	_GLenum_map[33375] = "GL_VIEWPORT_INDEX_PROVOKING_VERTEX_EXT"
	_GLenum_map[33375] = "GL_VIEWPORT_INDEX_PROVOKING_VERTEX"
	_GLenum_map[33376] = "GL_UNDEFINED_VERTEX"
	_GLenum_map[33376] = "GL_UNDEFINED_VERTEX_EXT"
	_GLenum_map[33376] = "GL_UNDEFINED_VERTEX_OES"
	_GLenum_map[33377] = "GL_NO_RESET_NOTIFICATION"
	_GLenum_map[33377] = "GL_NO_RESET_NOTIFICATION_ARB"
	_GLenum_map[33377] = "GL_NO_RESET_NOTIFICATION_EXT"
	_GLenum_map[33377] = "GL_NO_RESET_NOTIFICATION_KHR"
	_GLenum_map[33378] = "GL_MAX_COMPUTE_SHARED_MEMORY_SIZE"
	_GLenum_map[33379] = "GL_MAX_COMPUTE_UNIFORM_COMPONENTS"
	_GLenum_map[33380] = "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[33381] = "GL_MAX_COMPUTE_ATOMIC_COUNTERS"
	_GLenum_map[33382] = "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS"
	_GLenum_map[33383] = "GL_COMPUTE_WORK_GROUP_SIZE"
	_GLenum_map[33384] = "GL_DEBUG_TYPE_MARKER_KHR"
	_GLenum_map[33384] = "GL_DEBUG_TYPE_MARKER"
	_GLenum_map[33385] = "GL_DEBUG_TYPE_PUSH_GROUP_KHR"
	_GLenum_map[33385] = "GL_DEBUG_TYPE_PUSH_GROUP"
	_GLenum_map[33386] = "GL_DEBUG_TYPE_POP_GROUP_KHR"
	_GLenum_map[33386] = "GL_DEBUG_TYPE_POP_GROUP"
	_GLenum_map[33387] = "GL_DEBUG_SEVERITY_NOTIFICATION_KHR"
	_GLenum_map[33387] = "GL_DEBUG_SEVERITY_NOTIFICATION"
	_GLenum_map[33388] = "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR"
	_GLenum_map[33388] = "GL_MAX_DEBUG_GROUP_STACK_DEPTH"
	_GLenum_map[33389] = "GL_DEBUG_GROUP_STACK_DEPTH_KHR"
	_GLenum_map[33389] = "GL_DEBUG_GROUP_STACK_DEPTH"
	_GLenum_map[33390] = "GL_MAX_UNIFORM_LOCATIONS"
	_GLenum_map[33391] = "GL_INTERNALFORMAT_SUPPORTED"
	_GLenum_map[33392] = "GL_INTERNALFORMAT_PREFERRED"
	_GLenum_map[33393] = "GL_INTERNALFORMAT_RED_SIZE"
	_GLenum_map[33394] = "GL_INTERNALFORMAT_GREEN_SIZE"
	_GLenum_map[33395] = "GL_INTERNALFORMAT_BLUE_SIZE"
	_GLenum_map[33396] = "GL_INTERNALFORMAT_ALPHA_SIZE"
	_GLenum_map[33397] = "GL_INTERNALFORMAT_DEPTH_SIZE"
	_GLenum_map[33398] = "GL_INTERNALFORMAT_STENCIL_SIZE"
	_GLenum_map[33399] = "GL_INTERNALFORMAT_SHARED_SIZE"
	_GLenum_map[33400] = "GL_INTERNALFORMAT_RED_TYPE"
	_GLenum_map[33401] = "GL_INTERNALFORMAT_GREEN_TYPE"
	_GLenum_map[33402] = "GL_INTERNALFORMAT_BLUE_TYPE"
	_GLenum_map[33403] = "GL_INTERNALFORMAT_ALPHA_TYPE"
	_GLenum_map[33404] = "GL_INTERNALFORMAT_DEPTH_TYPE"
	_GLenum_map[33405] = "GL_INTERNALFORMAT_STENCIL_TYPE"
	_GLenum_map[33406] = "GL_MAX_WIDTH"
	_GLenum_map[33407] = "GL_MAX_HEIGHT"
	_GLenum_map[33408] = "GL_MAX_DEPTH"
	_GLenum_map[33409] = "GL_MAX_LAYERS"
	_GLenum_map[33410] = "GL_MAX_COMBINED_DIMENSIONS"
	_GLenum_map[33411] = "GL_COLOR_COMPONENTS"
	_GLenum_map[33412] = "GL_DEPTH_COMPONENTS"
	_GLenum_map[33413] = "GL_STENCIL_COMPONENTS"
	_GLenum_map[33414] = "GL_COLOR_RENDERABLE"
	_GLenum_map[33415] = "GL_DEPTH_RENDERABLE"
	_GLenum_map[33416] = "GL_STENCIL_RENDERABLE"
	_GLenum_map[33417] = "GL_FRAMEBUFFER_RENDERABLE"
	_GLenum_map[33418] = "GL_FRAMEBUFFER_RENDERABLE_LAYERED"
	_GLenum_map[33419] = "GL_FRAMEBUFFER_BLEND"
	_GLenum_map[33420] = "GL_READ_PIXELS"
	_GLenum_map[33421] = "GL_READ_PIXELS_FORMAT"
	_GLenum_map[33422] = "GL_READ_PIXELS_TYPE"
	_GLenum_map[33423] = "GL_TEXTURE_IMAGE_FORMAT"
	_GLenum_map[33424] = "GL_TEXTURE_IMAGE_TYPE"
	_GLenum_map[33425] = "GL_GET_TEXTURE_IMAGE_FORMAT"
	_GLenum_map[33426] = "GL_GET_TEXTURE_IMAGE_TYPE"
	_GLenum_map[33427] = "GL_MIPMAP"
	_GLenum_map[33428] = "GL_MANUAL_GENERATE_MIPMAP"
	_GLenum_map[33429] = "GL_AUTO_GENERATE_MIPMAP"
	_GLenum_map[33430] = "GL_COLOR_ENCODING"
	_GLenum_map[33431] = "GL_SRGB_READ"
	_GLenum_map[33432] = "GL_SRGB_WRITE"
	_GLenum_map[33433] = "GL_SRGB_DECODE_ARB"
	_GLenum_map[33434] = "GL_FILTER"
	_GLenum_map[33435] = "GL_VERTEX_TEXTURE"
	_GLenum_map[33436] = "GL_TESS_CONTROL_TEXTURE"
	_GLenum_map[33437] = "GL_TESS_EVALUATION_TEXTURE"
	_GLenum_map[33438] = "GL_GEOMETRY_TEXTURE"
	_GLenum_map[33439] = "GL_FRAGMENT_TEXTURE"
	_GLenum_map[33440] = "GL_COMPUTE_TEXTURE"
	_GLenum_map[33441] = "GL_TEXTURE_SHADOW"
	_GLenum_map[33442] = "GL_TEXTURE_GATHER"
	_GLenum_map[33443] = "GL_TEXTURE_GATHER_SHADOW"
	_GLenum_map[33444] = "GL_SHADER_IMAGE_LOAD"
	_GLenum_map[33445] = "GL_SHADER_IMAGE_STORE"
	_GLenum_map[33446] = "GL_SHADER_IMAGE_ATOMIC"
	_GLenum_map[33447] = "GL_IMAGE_TEXEL_SIZE"
	_GLenum_map[33448] = "GL_IMAGE_COMPATIBILITY_CLASS"
	_GLenum_map[33449] = "GL_IMAGE_PIXEL_FORMAT"
	_GLenum_map[33450] = "GL_IMAGE_PIXEL_TYPE"
	_GLenum_map[33452] = "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST"
	_GLenum_map[33453] = "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST"
	_GLenum_map[33454] = "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE"
	_GLenum_map[33455] = "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE"
	_GLenum_map[33457] = "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH"
	_GLenum_map[33458] = "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT"
	_GLenum_map[33459] = "GL_TEXTURE_COMPRESSED_BLOCK_SIZE"
	_GLenum_map[33460] = "GL_CLEAR_BUFFER"
	_GLenum_map[33461] = "GL_TEXTURE_VIEW"
	_GLenum_map[33462] = "GL_VIEW_COMPATIBILITY_CLASS"
	_GLenum_map[33463] = "GL_FULL_SUPPORT"
	_GLenum_map[33464] = "GL_CAVEAT_SUPPORT"
	_GLenum_map[33465] = "GL_IMAGE_CLASS_4_X_32"
	_GLenum_map[33466] = "GL_IMAGE_CLASS_2_X_32"
	_GLenum_map[33467] = "GL_IMAGE_CLASS_1_X_32"
	_GLenum_map[33468] = "GL_IMAGE_CLASS_4_X_16"
	_GLenum_map[33469] = "GL_IMAGE_CLASS_2_X_16"
	_GLenum_map[33470] = "GL_IMAGE_CLASS_1_X_16"
	_GLenum_map[33471] = "GL_IMAGE_CLASS_4_X_8"
	_GLenum_map[33472] = "GL_IMAGE_CLASS_2_X_8"
	_GLenum_map[33473] = "GL_IMAGE_CLASS_1_X_8"
	_GLenum_map[33474] = "GL_IMAGE_CLASS_11_11_10"
	_GLenum_map[33475] = "GL_IMAGE_CLASS_10_10_10_2"
	_GLenum_map[33476] = "GL_VIEW_CLASS_128_BITS"
	_GLenum_map[33477] = "GL_VIEW_CLASS_96_BITS"
	_GLenum_map[33478] = "GL_VIEW_CLASS_64_BITS"
	_GLenum_map[33479] = "GL_VIEW_CLASS_48_BITS"
	_GLenum_map[33480] = "GL_VIEW_CLASS_32_BITS"
	_GLenum_map[33481] = "GL_VIEW_CLASS_24_BITS"
	_GLenum_map[33482] = "GL_VIEW_CLASS_16_BITS"
	_GLenum_map[33483] = "GL_VIEW_CLASS_8_BITS"
	_GLenum_map[33484] = "GL_VIEW_CLASS_S3TC_DXT1_RGB"
	_GLenum_map[33485] = "GL_VIEW_CLASS_S3TC_DXT1_RGBA"
	_GLenum_map[33486] = "GL_VIEW_CLASS_S3TC_DXT3_RGBA"
	_GLenum_map[33487] = "GL_VIEW_CLASS_S3TC_DXT5_RGBA"
	_GLenum_map[33488] = "GL_VIEW_CLASS_RGTC1_RED"
	_GLenum_map[33489] = "GL_VIEW_CLASS_RGTC2_RG"
	_GLenum_map[33490] = "GL_VIEW_CLASS_BPTC_UNORM"
	_GLenum_map[33491] = "GL_VIEW_CLASS_BPTC_FLOAT"
	_GLenum_map[33492] = "GL_VERTEX_ATTRIB_BINDING"
	_GLenum_map[33493] = "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"
	_GLenum_map[33494] = "GL_VERTEX_BINDING_DIVISOR"
	_GLenum_map[33495] = "GL_VERTEX_BINDING_OFFSET"
	_GLenum_map[33496] = "GL_VERTEX_BINDING_STRIDE"
	_GLenum_map[33497] = "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET"
	_GLenum_map[33498] = "GL_MAX_VERTEX_ATTRIB_BINDINGS"
	_GLenum_map[33499] = "GL_TEXTURE_VIEW_MIN_LEVEL_OES"
	_GLenum_map[33499] = "GL_TEXTURE_VIEW_MIN_LEVEL_EXT"
	_GLenum_map[33499] = "GL_TEXTURE_VIEW_MIN_LEVEL"
	_GLenum_map[33500] = "GL_TEXTURE_VIEW_NUM_LEVELS_OES"
	_GLenum_map[33500] = "GL_TEXTURE_VIEW_NUM_LEVELS"
	_GLenum_map[33500] = "GL_TEXTURE_VIEW_NUM_LEVELS_EXT"
	_GLenum_map[33501] = "GL_TEXTURE_VIEW_MIN_LAYER_EXT"
	_GLenum_map[33501] = "GL_TEXTURE_VIEW_MIN_LAYER"
	_GLenum_map[33501] = "GL_TEXTURE_VIEW_MIN_LAYER_OES"
	_GLenum_map[33502] = "GL_TEXTURE_VIEW_NUM_LAYERS"
	_GLenum_map[33502] = "GL_TEXTURE_VIEW_NUM_LAYERS_EXT"
	_GLenum_map[33502] = "GL_TEXTURE_VIEW_NUM_LAYERS_OES"
	_GLenum_map[33503] = "GL_TEXTURE_IMMUTABLE_LEVELS"
	_GLenum_map[33504] = "GL_BUFFER"
	_GLenum_map[33504] = "GL_BUFFER_KHR"
	_GLenum_map[33505] = "GL_SHADER_KHR"
	_GLenum_map[33505] = "GL_SHADER"
	_GLenum_map[33506] = "GL_PROGRAM"
	_GLenum_map[33506] = "GL_PROGRAM_KHR"
	_GLenum_map[33507] = "GL_QUERY"
	_GLenum_map[33507] = "GL_QUERY_KHR"
	_GLenum_map[33508] = "GL_PROGRAM_PIPELINE_KHR"
	_GLenum_map[33508] = "GL_PROGRAM_PIPELINE"
	_GLenum_map[33509] = "GL_MAX_VERTEX_ATTRIB_STRIDE"
	_GLenum_map[33510] = "GL_SAMPLER"
	_GLenum_map[33510] = "GL_SAMPLER_KHR"
	_GLenum_map[33511] = "GL_DISPLAY_LIST"
	_GLenum_map[33512] = "GL_MAX_LABEL_LENGTH"
	_GLenum_map[33512] = "GL_MAX_LABEL_LENGTH_KHR"
	_GLenum_map[33513] = "GL_NUM_SHADING_LANGUAGE_VERSIONS"
	_GLenum_map[33514] = "GL_QUERY_TARGET"
	_GLenum_map[33516] = "GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB"
	_GLenum_map[33517] = "GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB"
	_GLenum_map[33518] = "GL_VERTICES_SUBMITTED_ARB"
	_GLenum_map[33519] = "GL_PRIMITIVES_SUBMITTED_ARB"
	_GLenum_map[33520] = "GL_VERTEX_SHADER_INVOCATIONS_ARB"
	_GLenum_map[33521] = "GL_TESS_CONTROL_SHADER_PATCHES_ARB"
	_GLenum_map[33522] = "GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB"
	_GLenum_map[33523] = "GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB"
	_GLenum_map[33524] = "GL_FRAGMENT_SHADER_INVOCATIONS_ARB"
	_GLenum_map[33525] = "GL_COMPUTE_SHADER_INVOCATIONS_ARB"
	_GLenum_map[33526] = "GL_CLIPPING_INPUT_PRIMITIVES_ARB"
	_GLenum_map[33527] = "GL_CLIPPING_OUTPUT_PRIMITIVES_ARB"
	_GLenum_map[33528] = "GL_SPARSE_BUFFER_PAGE_SIZE_ARB"
	_GLenum_map[33529] = "GL_MAX_CULL_DISTANCES"
	_GLenum_map[33530] = "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES"
	_GLenum_map[33531] = "GL_CONTEXT_RELEASE_BEHAVIOR"
	_GLenum_map[33531] = "GL_CONTEXT_RELEASE_BEHAVIOR_KHR"
	_GLenum_map[33532] = "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR"
	_GLenum_map[33532] = "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH"
	_GLenum_map[33552] = "GL_DEPTH_PASS_INSTRUMENT_SGIX"
	_GLenum_map[33553] = "GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX"
	_GLenum_map[33554] = "GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX"
	_GLenum_map[33555] = "GL_FRAGMENTS_INSTRUMENT_SGIX"
	_GLenum_map[33556] = "GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX"
	_GLenum_map[33557] = "GL_FRAGMENTS_INSTRUMENT_MAX_SGIX"
	_GLenum_map[33558] = "GL_CONVOLUTION_HINT_SGIX"
	_GLenum_map[33560] = "GL_YCRCB_SGIX"
	_GLenum_map[33561] = "GL_YCRCBA_SGIX"
	_GLenum_map[33562] = "GL_UNPACK_COMPRESSED_SIZE_SGIX"
	_GLenum_map[33563] = "GL_PACK_MAX_COMPRESSED_SIZE_SGIX"
	_GLenum_map[33564] = "GL_PACK_COMPRESSED_SIZE_SGIX"
	_GLenum_map[33565] = "GL_SLIM8U_SGIX"
	_GLenum_map[33566] = "GL_SLIM10U_SGIX"
	_GLenum_map[33567] = "GL_SLIM12S_SGIX"
	_GLenum_map[33568] = "GL_ALPHA_MIN_SGIX"
	_GLenum_map[33569] = "GL_ALPHA_MAX_SGIX"
	_GLenum_map[33570] = "GL_SCALEBIAS_HINT_SGIX"
	_GLenum_map[33577] = "GL_ASYNC_MARKER_SGIX"
	_GLenum_map[33579] = "GL_PIXEL_TEX_GEN_MODE_SGIX"
	_GLenum_map[33580] = "GL_ASYNC_HISTOGRAM_SGIX"
	_GLenum_map[33581] = "GL_MAX_ASYNC_HISTOGRAM_SGIX"
	_GLenum_map[33584] = "GL_PIXEL_TRANSFORM_2D_EXT"
	_GLenum_map[33585] = "GL_PIXEL_MAG_FILTER_EXT"
	_GLenum_map[33586] = "GL_PIXEL_MIN_FILTER_EXT"
	_GLenum_map[33587] = "GL_PIXEL_CUBIC_WEIGHT_EXT"
	_GLenum_map[33588] = "GL_CUBIC_EXT"
	_GLenum_map[33589] = "GL_AVERAGE_EXT"
	_GLenum_map[33590] = "GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT"
	_GLenum_map[33591] = "GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT"
	_GLenum_map[33592] = "GL_PIXEL_TRANSFORM_2D_MATRIX_EXT"
	_GLenum_map[33609] = "GL_FRAGMENT_MATERIAL_EXT"
	_GLenum_map[33610] = "GL_FRAGMENT_NORMAL_EXT"
	_GLenum_map[33612] = "GL_FRAGMENT_COLOR_EXT"
	_GLenum_map[33613] = "GL_ATTENUATION_EXT"
	_GLenum_map[33614] = "GL_SHADOW_ATTENUATION_EXT"
	_GLenum_map[33615] = "GL_TEXTURE_APPLICATION_MODE_EXT"
	_GLenum_map[33616] = "GL_TEXTURE_LIGHT_EXT"
	_GLenum_map[33617] = "GL_TEXTURE_MATERIAL_FACE_EXT"
	_GLenum_map[33618] = "GL_TEXTURE_MATERIAL_PARAMETER_EXT"
	_GLenum_map[33619] = "GL_PIXEL_TEXTURE_SGIS"
	_GLenum_map[33620] = "GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS"
	_GLenum_map[33621] = "GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS"
	_GLenum_map[33622] = "GL_PIXEL_GROUP_COLOR_SGIS"
	_GLenum_map[33627] = "GL_LINE_QUALITY_HINT_SGIX"
	_GLenum_map[33628] = "GL_ASYNC_TEX_IMAGE_SGIX"
	_GLenum_map[33629] = "GL_ASYNC_DRAW_PIXELS_SGIX"
	_GLenum_map[33630] = "GL_ASYNC_READ_PIXELS_SGIX"
	_GLenum_map[33631] = "GL_MAX_ASYNC_TEX_IMAGE_SGIX"
	_GLenum_map[33632] = "GL_MAX_ASYNC_DRAW_PIXELS_SGIX"
	_GLenum_map[33633] = "GL_MAX_ASYNC_READ_PIXELS_SGIX"
	_GLenum_map[33634] = "GL_UNSIGNED_BYTE_2_3_3_REV_EXT"
	_GLenum_map[33634] = "GL_UNSIGNED_BYTE_2_3_3_REV"
	_GLenum_map[33635] = "GL_UNSIGNED_SHORT_5_6_5"
	_GLenum_map[33635] = "GL_UNSIGNED_SHORT_5_6_5_EXT"
	_GLenum_map[33636] = "GL_UNSIGNED_SHORT_5_6_5_REV_EXT"
	_GLenum_map[33636] = "GL_UNSIGNED_SHORT_5_6_5_REV"
	_GLenum_map[33637] = "GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG"
	_GLenum_map[33637] = "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT"
	_GLenum_map[33637] = "GL_UNSIGNED_SHORT_4_4_4_4_REV"
	_GLenum_map[33638] = "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT"
	_GLenum_map[33638] = "GL_UNSIGNED_SHORT_1_5_5_5_REV"
	_GLenum_map[33639] = "GL_UNSIGNED_INT_8_8_8_8_REV_EXT"
	_GLenum_map[33639] = "GL_UNSIGNED_INT_8_8_8_8_REV"
	_GLenum_map[33640] = "GL_UNSIGNED_INT_2_10_10_10_REV_EXT"
	_GLenum_map[33640] = "GL_UNSIGNED_INT_2_10_10_10_REV"
	_GLenum_map[33641] = "GL_TEXTURE_MAX_CLAMP_S_SGIX"
	_GLenum_map[33642] = "GL_TEXTURE_MAX_CLAMP_T_SGIX"
	_GLenum_map[33643] = "GL_TEXTURE_MAX_CLAMP_R_SGIX"
	_GLenum_map[33648] = "GL_MIRRORED_REPEAT_ARB"
	_GLenum_map[33648] = "GL_MIRRORED_REPEAT"
	_GLenum_map[33648] = "GL_MIRRORED_REPEAT_OES"
	_GLenum_map[33648] = "GL_MIRRORED_REPEAT_IBM"
	_GLenum_map[33696] = "GL_RGB_S3TC"
	_GLenum_map[33697] = "GL_RGB4_S3TC"
	_GLenum_map[33698] = "GL_RGBA_S3TC"
	_GLenum_map[33699] = "GL_RGBA4_S3TC"
	_GLenum_map[33700] = "GL_RGBA_DXT5_S3TC"
	_GLenum_map[33701] = "GL_RGBA4_DXT5_S3TC"
	_GLenum_map[33774] = "GL_VERTEX_PRECLIP_SGIX"
	_GLenum_map[33775] = "GL_VERTEX_PRECLIP_HINT_SGIX"
	_GLenum_map[33776] = "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"
	_GLenum_map[33777] = "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"
	_GLenum_map[33778] = "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE"
	_GLenum_map[33778] = "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"
	_GLenum_map[33779] = "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"
	_GLenum_map[33779] = "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE"
	_GLenum_map[33780] = "GL_PARALLEL_ARRAYS_INTEL"
	_GLenum_map[33781] = "GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL"
	_GLenum_map[33782] = "GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL"
	_GLenum_map[33783] = "GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL"
	_GLenum_map[33784] = "GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL"
	_GLenum_map[33785] = "GL_PERFQUERY_DONOT_FLUSH_INTEL"
	_GLenum_map[33786] = "GL_PERFQUERY_FLUSH_INTEL"
	_GLenum_map[33787] = "GL_PERFQUERY_WAIT_INTEL"
	_GLenum_map[33791] = "GL_TEXTURE_MEMORY_LAYOUT_INTEL"
	_GLenum_map[33792] = "GL_FRAGMENT_LIGHTING_SGIX"
	_GLenum_map[33793] = "GL_FRAGMENT_COLOR_MATERIAL_SGIX"
	_GLenum_map[33794] = "GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX"
	_GLenum_map[33795] = "GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX"
	_GLenum_map[33796] = "GL_MAX_FRAGMENT_LIGHTS_SGIX"
	_GLenum_map[33797] = "GL_MAX_ACTIVE_LIGHTS_SGIX"
	_GLenum_map[33798] = "GL_CURRENT_RASTER_NORMAL_SGIX"
	_GLenum_map[33799] = "GL_LIGHT_ENV_MODE_SGIX"
	_GLenum_map[33800] = "GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX"
	_GLenum_map[33801] = "GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX"
	_GLenum_map[33802] = "GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX"
	_GLenum_map[33803] = "GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX"
	_GLenum_map[33804] = "GL_FRAGMENT_LIGHT0_SGIX"
	_GLenum_map[33805] = "GL_FRAGMENT_LIGHT1_SGIX"
	_GLenum_map[33806] = "GL_FRAGMENT_LIGHT2_SGIX"
	_GLenum_map[33807] = "GL_FRAGMENT_LIGHT3_SGIX"
	_GLenum_map[33808] = "GL_FRAGMENT_LIGHT4_SGIX"
	_GLenum_map[33809] = "GL_FRAGMENT_LIGHT5_SGIX"
	_GLenum_map[33810] = "GL_FRAGMENT_LIGHT6_SGIX"
	_GLenum_map[33811] = "GL_FRAGMENT_LIGHT7_SGIX"
	_GLenum_map[33838] = "GL_PACK_RESAMPLE_SGIX"
	_GLenum_map[33839] = "GL_UNPACK_RESAMPLE_SGIX"
	_GLenum_map[33840] = "GL_RESAMPLE_DECIMATE_SGIX"
	_GLenum_map[33843] = "GL_RESAMPLE_REPLICATE_SGIX"
	_GLenum_map[33844] = "GL_RESAMPLE_ZERO_FILL_SGIX"
	_GLenum_map[33849] = "GL_TANGENT_ARRAY_EXT"
	_GLenum_map[33850] = "GL_BINORMAL_ARRAY_EXT"
	_GLenum_map[33851] = "GL_CURRENT_TANGENT_EXT"
	_GLenum_map[33852] = "GL_CURRENT_BINORMAL_EXT"
	_GLenum_map[33854] = "GL_TANGENT_ARRAY_TYPE_EXT"
	_GLenum_map[33855] = "GL_TANGENT_ARRAY_STRIDE_EXT"
	_GLenum_map[33856] = "GL_BINORMAL_ARRAY_TYPE_EXT"
	_GLenum_map[33857] = "GL_BINORMAL_ARRAY_STRIDE_EXT"
	_GLenum_map[33858] = "GL_TANGENT_ARRAY_POINTER_EXT"
	_GLenum_map[33859] = "GL_BINORMAL_ARRAY_POINTER_EXT"
	_GLenum_map[33860] = "GL_MAP1_TANGENT_EXT"
	_GLenum_map[33861] = "GL_MAP2_TANGENT_EXT"
	_GLenum_map[33862] = "GL_MAP1_BINORMAL_EXT"
	_GLenum_map[33863] = "GL_MAP2_BINORMAL_EXT"
	_GLenum_map[33869] = "GL_NEAREST_CLIPMAP_NEAREST_SGIX"
	_GLenum_map[33870] = "GL_NEAREST_CLIPMAP_LINEAR_SGIX"
	_GLenum_map[33871] = "GL_LINEAR_CLIPMAP_NEAREST_SGIX"
	_GLenum_map[33872] = "GL_FOG_COORDINATE_SOURCE"
	_GLenum_map[33872] = "GL_FOG_COORDINATE_SOURCE_EXT"
	_GLenum_map[33872] = "GL_FOG_COORD_SRC"
	_GLenum_map[33873] = "GL_FOG_COORDINATE_EXT"
	_GLenum_map[33873] = "GL_FOG_COORDINATE"
	_GLenum_map[33873] = "GL_FOG_COORD"
	_GLenum_map[33874] = "GL_FRAGMENT_DEPTH"
	_GLenum_map[33874] = "GL_FRAGMENT_DEPTH_EXT"
	_GLenum_map[33875] = "GL_CURRENT_FOG_COORD"
	_GLenum_map[33875] = "GL_CURRENT_FOG_COORDINATE_EXT"
	_GLenum_map[33875] = "GL_CURRENT_FOG_COORDINATE"
	_GLenum_map[33876] = "GL_FOG_COORDINATE_ARRAY_TYPE_EXT"
	_GLenum_map[33876] = "GL_FOG_COORD_ARRAY_TYPE"
	_GLenum_map[33876] = "GL_FOG_COORDINATE_ARRAY_TYPE"
	_GLenum_map[33877] = "GL_FOG_COORD_ARRAY_STRIDE"
	_GLenum_map[33877] = "GL_FOG_COORDINATE_ARRAY_STRIDE_EXT"
	_GLenum_map[33877] = "GL_FOG_COORDINATE_ARRAY_STRIDE"
	_GLenum_map[33878] = "GL_FOG_COORDINATE_ARRAY_POINTER_EXT"
	_GLenum_map[33878] = "GL_FOG_COORD_ARRAY_POINTER"
	_GLenum_map[33878] = "GL_FOG_COORDINATE_ARRAY_POINTER"
	_GLenum_map[33879] = "GL_FOG_COORD_ARRAY"
	_GLenum_map[33879] = "GL_FOG_COORDINATE_ARRAY_EXT"
	_GLenum_map[33879] = "GL_FOG_COORDINATE_ARRAY"
	_GLenum_map[33880] = "GL_COLOR_SUM"
	_GLenum_map[33880] = "GL_COLOR_SUM_EXT"
	_GLenum_map[33880] = "GL_COLOR_SUM_ARB"
	_GLenum_map[33881] = "GL_CURRENT_SECONDARY_COLOR"
	_GLenum_map[33881] = "GL_CURRENT_SECONDARY_COLOR_EXT"
	_GLenum_map[33882] = "GL_SECONDARY_COLOR_ARRAY_SIZE_EXT"
	_GLenum_map[33882] = "GL_SECONDARY_COLOR_ARRAY_SIZE"
	_GLenum_map[33883] = "GL_SECONDARY_COLOR_ARRAY_TYPE_EXT"
	_GLenum_map[33883] = "GL_SECONDARY_COLOR_ARRAY_TYPE"
	_GLenum_map[33884] = "GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT"
	_GLenum_map[33884] = "GL_SECONDARY_COLOR_ARRAY_STRIDE"
	_GLenum_map[33885] = "GL_SECONDARY_COLOR_ARRAY_POINTER_EXT"
	_GLenum_map[33885] = "GL_SECONDARY_COLOR_ARRAY_POINTER"
	_GLenum_map[33886] = "GL_SECONDARY_COLOR_ARRAY"
	_GLenum_map[33886] = "GL_SECONDARY_COLOR_ARRAY_EXT"
	_GLenum_map[33887] = "GL_CURRENT_RASTER_SECONDARY_COLOR"
	_GLenum_map[33901] = "GL_ALIASED_POINT_SIZE_RANGE"
	_GLenum_map[33902] = "GL_ALIASED_LINE_WIDTH_RANGE"
	_GLenum_map[33936] = "GL_SCREEN_COORDINATES_REND"
	_GLenum_map[33937] = "GL_INVERTED_SCREEN_W_REND"
	_GLenum_map[33984] = "GL_TEXTURE0_ARB"
	_GLenum_map[33984] = "GL_TEXTURE0"
	_GLenum_map[33985] = "GL_TEXTURE1_ARB"
	_GLenum_map[33985] = "GL_TEXTURE1"
	_GLenum_map[33986] = "GL_TEXTURE2"
	_GLenum_map[33986] = "GL_TEXTURE2_ARB"
	_GLenum_map[33987] = "GL_TEXTURE3_ARB"
	_GLenum_map[33987] = "GL_TEXTURE3"
	_GLenum_map[33988] = "GL_TEXTURE4_ARB"
	_GLenum_map[33988] = "GL_TEXTURE4"
	_GLenum_map[33989] = "GL_TEXTURE5"
	_GLenum_map[33989] = "GL_TEXTURE5_ARB"
	_GLenum_map[33990] = "GL_TEXTURE6_ARB"
	_GLenum_map[33990] = "GL_TEXTURE6"
	_GLenum_map[33991] = "GL_TEXTURE7"
	_GLenum_map[33991] = "GL_TEXTURE7_ARB"
	_GLenum_map[33992] = "GL_TEXTURE8"
	_GLenum_map[33992] = "GL_TEXTURE8_ARB"
	_GLenum_map[33993] = "GL_TEXTURE9_ARB"
	_GLenum_map[33993] = "GL_TEXTURE9"
	_GLenum_map[33994] = "GL_TEXTURE10_ARB"
	_GLenum_map[33994] = "GL_TEXTURE10"
	_GLenum_map[33995] = "GL_TEXTURE11"
	_GLenum_map[33995] = "GL_TEXTURE11_ARB"
	_GLenum_map[33996] = "GL_TEXTURE12_ARB"
	_GLenum_map[33996] = "GL_TEXTURE12"
	_GLenum_map[33997] = "GL_TEXTURE13"
	_GLenum_map[33997] = "GL_TEXTURE13_ARB"
	_GLenum_map[33998] = "GL_TEXTURE14"
	_GLenum_map[33998] = "GL_TEXTURE14_ARB"
	_GLenum_map[33999] = "GL_TEXTURE15"
	_GLenum_map[33999] = "GL_TEXTURE15_ARB"
	_GLenum_map[34000] = "GL_TEXTURE16_ARB"
	_GLenum_map[34000] = "GL_TEXTURE16"
	_GLenum_map[34001] = "GL_TEXTURE17_ARB"
	_GLenum_map[34001] = "GL_TEXTURE17"
	_GLenum_map[34002] = "GL_TEXTURE18_ARB"
	_GLenum_map[34002] = "GL_TEXTURE18"
	_GLenum_map[34003] = "GL_TEXTURE19_ARB"
	_GLenum_map[34003] = "GL_TEXTURE19"
	_GLenum_map[34004] = "GL_TEXTURE20_ARB"
	_GLenum_map[34004] = "GL_TEXTURE20"
	_GLenum_map[34005] = "GL_TEXTURE21"
	_GLenum_map[34005] = "GL_TEXTURE21_ARB"
	_GLenum_map[34006] = "GL_TEXTURE22"
	_GLenum_map[34006] = "GL_TEXTURE22_ARB"
	_GLenum_map[34007] = "GL_TEXTURE23_ARB"
	_GLenum_map[34007] = "GL_TEXTURE23"
	_GLenum_map[34008] = "GL_TEXTURE24_ARB"
	_GLenum_map[34008] = "GL_TEXTURE24"
	_GLenum_map[34009] = "GL_TEXTURE25"
	_GLenum_map[34009] = "GL_TEXTURE25_ARB"
	_GLenum_map[34010] = "GL_TEXTURE26_ARB"
	_GLenum_map[34010] = "GL_TEXTURE26"
	_GLenum_map[34011] = "GL_TEXTURE27_ARB"
	_GLenum_map[34011] = "GL_TEXTURE27"
	_GLenum_map[34012] = "GL_TEXTURE28"
	_GLenum_map[34012] = "GL_TEXTURE28_ARB"
	_GLenum_map[34013] = "GL_TEXTURE29"
	_GLenum_map[34013] = "GL_TEXTURE29_ARB"
	_GLenum_map[34014] = "GL_TEXTURE30"
	_GLenum_map[34014] = "GL_TEXTURE30_ARB"
	_GLenum_map[34015] = "GL_TEXTURE31_ARB"
	_GLenum_map[34015] = "GL_TEXTURE31"
	_GLenum_map[34016] = "GL_ACTIVE_TEXTURE_ARB"
	_GLenum_map[34016] = "GL_ACTIVE_TEXTURE"
	_GLenum_map[34017] = "GL_CLIENT_ACTIVE_TEXTURE_ARB"
	_GLenum_map[34017] = "GL_CLIENT_ACTIVE_TEXTURE"
	_GLenum_map[34018] = "GL_MAX_TEXTURE_UNITS_ARB"
	_GLenum_map[34018] = "GL_MAX_TEXTURE_UNITS"
	_GLenum_map[34019] = "GL_TRANSPOSE_MODELVIEW_MATRIX"
	_GLenum_map[34019] = "GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV"
	_GLenum_map[34019] = "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB"
	_GLenum_map[34020] = "GL_TRANSPOSE_PROJECTION_MATRIX_ARB"
	_GLenum_map[34020] = "GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV"
	_GLenum_map[34020] = "GL_TRANSPOSE_PROJECTION_MATRIX"
	_GLenum_map[34021] = "GL_TRANSPOSE_TEXTURE_MATRIX_ARB"
	_GLenum_map[34021] = "GL_TRANSPOSE_TEXTURE_MATRIX"
	_GLenum_map[34022] = "GL_TRANSPOSE_COLOR_MATRIX"
	_GLenum_map[34022] = "GL_TRANSPOSE_COLOR_MATRIX_ARB"
	_GLenum_map[34023] = "GL_SUBTRACT_ARB"
	_GLenum_map[34023] = "GL_SUBTRACT"
	_GLenum_map[34024] = "GL_MAX_RENDERBUFFER_SIZE"
	_GLenum_map[34024] = "GL_MAX_RENDERBUFFER_SIZE_OES"
	_GLenum_map[34024] = "GL_MAX_RENDERBUFFER_SIZE_EXT"
	_GLenum_map[34025] = "GL_COMPRESSED_ALPHA_ARB"
	_GLenum_map[34025] = "GL_COMPRESSED_ALPHA"
	_GLenum_map[34026] = "GL_COMPRESSED_LUMINANCE"
	_GLenum_map[34026] = "GL_COMPRESSED_LUMINANCE_ARB"
	_GLenum_map[34027] = "GL_COMPRESSED_LUMINANCE_ALPHA"
	_GLenum_map[34027] = "GL_COMPRESSED_LUMINANCE_ALPHA_ARB"
	_GLenum_map[34028] = "GL_COMPRESSED_INTENSITY"
	_GLenum_map[34028] = "GL_COMPRESSED_INTENSITY_ARB"
	_GLenum_map[34029] = "GL_COMPRESSED_RGB"
	_GLenum_map[34029] = "GL_COMPRESSED_RGB_ARB"
	_GLenum_map[34030] = "GL_COMPRESSED_RGBA"
	_GLenum_map[34030] = "GL_COMPRESSED_RGBA_ARB"
	_GLenum_map[34031] = "GL_TEXTURE_COMPRESSION_HINT_ARB"
	_GLenum_map[34031] = "GL_TEXTURE_COMPRESSION_HINT"
	_GLenum_map[34032] = "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER"
	_GLenum_map[34033] = "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER"
	_GLenum_map[34034] = "GL_ALL_COMPLETED_NV"
	_GLenum_map[34035] = "GL_FENCE_STATUS_NV"
	_GLenum_map[34036] = "GL_FENCE_CONDITION_NV"
	_GLenum_map[34037] = "GL_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34037] = "GL_TEXTURE_RECTANGLE"
	_GLenum_map[34037] = "GL_TEXTURE_RECTANGLE_ARB"
	_GLenum_map[34038] = "GL_TEXTURE_BINDING_RECTANGLE_NV"
	_GLenum_map[34038] = "GL_TEXTURE_BINDING_RECTANGLE_ARB"
	_GLenum_map[34038] = "GL_TEXTURE_BINDING_RECTANGLE"
	_GLenum_map[34039] = "GL_PROXY_TEXTURE_RECTANGLE"
	_GLenum_map[34039] = "GL_PROXY_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34039] = "GL_PROXY_TEXTURE_RECTANGLE_ARB"
	_GLenum_map[34040] = "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV"
	_GLenum_map[34040] = "GL_MAX_RECTANGLE_TEXTURE_SIZE"
	_GLenum_map[34040] = "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB"
	_GLenum_map[34041] = "GL_DEPTH_STENCIL_NV"
	_GLenum_map[34041] = "GL_DEPTH_STENCIL_EXT"
	_GLenum_map[34041] = "GL_DEPTH_STENCIL_OES"
	_GLenum_map[34041] = "GL_DEPTH_STENCIL"
	_GLenum_map[34042] = "GL_UNSIGNED_INT_24_8_EXT"
	_GLenum_map[34042] = "GL_UNSIGNED_INT_24_8_OES"
	_GLenum_map[34042] = "GL_UNSIGNED_INT_24_8_NV"
	_GLenum_map[34042] = "GL_UNSIGNED_INT_24_8"
	_GLenum_map[34045] = "GL_MAX_TEXTURE_LOD_BIAS_EXT"
	_GLenum_map[34045] = "GL_MAX_TEXTURE_LOD_BIAS"
	_GLenum_map[34046] = "GL_TEXTURE_MAX_ANISOTROPY_EXT"
	_GLenum_map[34047] = "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT"
	_GLenum_map[34048] = "GL_TEXTURE_FILTER_CONTROL"
	_GLenum_map[34048] = "GL_TEXTURE_FILTER_CONTROL_EXT"
	_GLenum_map[34049] = "GL_TEXTURE_LOD_BIAS"
	_GLenum_map[34049] = "GL_TEXTURE_LOD_BIAS_EXT"
	_GLenum_map[34050] = "GL_MODELVIEW1_STACK_DEPTH_EXT"
	_GLenum_map[34051] = "GL_COMBINE4_NV"
	_GLenum_map[34052] = "GL_MAX_SHININESS_NV"
	_GLenum_map[34053] = "GL_MAX_SPOT_EXPONENT_NV"
	_GLenum_map[34054] = "GL_MODELVIEW1_MATRIX_EXT"
	_GLenum_map[34055] = "GL_INCR_WRAP_EXT"
	_GLenum_map[34055] = "GL_INCR_WRAP"
	_GLenum_map[34055] = "GL_INCR_WRAP_OES"
	_GLenum_map[34056] = "GL_DECR_WRAP_EXT"
	_GLenum_map[34056] = "GL_DECR_WRAP_OES"
	_GLenum_map[34056] = "GL_DECR_WRAP"
	_GLenum_map[34057] = "GL_VERTEX_WEIGHTING_EXT"
	_GLenum_map[34058] = "GL_MODELVIEW1_EXT"
	_GLenum_map[34058] = "GL_MODELVIEW1_ARB"
	_GLenum_map[34059] = "GL_CURRENT_VERTEX_WEIGHT_EXT"
	_GLenum_map[34060] = "GL_VERTEX_WEIGHT_ARRAY_EXT"
	_GLenum_map[34061] = "GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT"
	_GLenum_map[34062] = "GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT"
	_GLenum_map[34063] = "GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT"
	_GLenum_map[34064] = "GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT"
	_GLenum_map[34065] = "GL_NORMAL_MAP_EXT"
	_GLenum_map[34065] = "GL_NORMAL_MAP"
	_GLenum_map[34065] = "GL_NORMAL_MAP_OES"
	_GLenum_map[34065] = "GL_NORMAL_MAP_NV"
	_GLenum_map[34065] = "GL_NORMAL_MAP_ARB"
	_GLenum_map[34066] = "GL_REFLECTION_MAP_ARB"
	_GLenum_map[34066] = "GL_REFLECTION_MAP_OES"
	_GLenum_map[34066] = "GL_REFLECTION_MAP_NV"
	_GLenum_map[34066] = "GL_REFLECTION_MAP_EXT"
	_GLenum_map[34066] = "GL_REFLECTION_MAP"
	_GLenum_map[34067] = "GL_TEXTURE_CUBE_MAP_OES"
	_GLenum_map[34067] = "GL_TEXTURE_CUBE_MAP_EXT"
	_GLenum_map[34067] = "GL_TEXTURE_CUBE_MAP_ARB"
	_GLenum_map[34067] = "GL_TEXTURE_CUBE_MAP"
	_GLenum_map[34068] = "GL_TEXTURE_BINDING_CUBE_MAP_EXT"
	_GLenum_map[34068] = "GL_TEXTURE_BINDING_CUBE_MAP_ARB"
	_GLenum_map[34068] = "GL_TEXTURE_BINDING_CUBE_MAP_OES"
	_GLenum_map[34068] = "GL_TEXTURE_BINDING_CUBE_MAP"
	_GLenum_map[34069] = "GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES"
	_GLenum_map[34069] = "GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT"
	_GLenum_map[34069] = "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB"
	_GLenum_map[34069] = "GL_TEXTURE_CUBE_MAP_POSITIVE_X"
	_GLenum_map[34070] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES"
	_GLenum_map[34070] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"
	_GLenum_map[34070] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB"
	_GLenum_map[34070] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT"
	_GLenum_map[34071] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB"
	_GLenum_map[34071] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT"
	_GLenum_map[34071] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"
	_GLenum_map[34071] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES"
	_GLenum_map[34072] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB"
	_GLenum_map[34072] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT"
	_GLenum_map[34072] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES"
	_GLenum_map[34072] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"
	_GLenum_map[34073] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"
	_GLenum_map[34073] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT"
	_GLenum_map[34073] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES"
	_GLenum_map[34073] = "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB"
	_GLenum_map[34074] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB"
	_GLenum_map[34074] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES"
	_GLenum_map[34074] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT"
	_GLenum_map[34074] = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"
	_GLenum_map[34075] = "GL_PROXY_TEXTURE_CUBE_MAP"
	_GLenum_map[34075] = "GL_PROXY_TEXTURE_CUBE_MAP_EXT"
	_GLenum_map[34075] = "GL_PROXY_TEXTURE_CUBE_MAP_ARB"
	_GLenum_map[34076] = "GL_MAX_CUBE_MAP_TEXTURE_SIZE"
	_GLenum_map[34076] = "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB"
	_GLenum_map[34076] = "GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT"
	_GLenum_map[34076] = "GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES"
	_GLenum_map[34077] = "GL_VERTEX_ARRAY_RANGE_APPLE"
	_GLenum_map[34077] = "GL_VERTEX_ARRAY_RANGE_NV"
	_GLenum_map[34078] = "GL_VERTEX_ARRAY_RANGE_LENGTH_NV"
	_GLenum_map[34078] = "GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE"
	_GLenum_map[34079] = "GL_VERTEX_ARRAY_RANGE_VALID_NV"
	_GLenum_map[34079] = "GL_VERTEX_ARRAY_STORAGE_HINT_APPLE"
	_GLenum_map[34080] = "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV"
	_GLenum_map[34081] = "GL_VERTEX_ARRAY_RANGE_POINTER_APPLE"
	_GLenum_map[34081] = "GL_VERTEX_ARRAY_RANGE_POINTER_NV"
	_GLenum_map[34082] = "GL_REGISTER_COMBINERS_NV"
	_GLenum_map[34083] = "GL_VARIABLE_A_NV"
	_GLenum_map[34084] = "GL_VARIABLE_B_NV"
	_GLenum_map[34085] = "GL_VARIABLE_C_NV"
	_GLenum_map[34086] = "GL_VARIABLE_D_NV"
	_GLenum_map[34087] = "GL_VARIABLE_E_NV"
	_GLenum_map[34088] = "GL_VARIABLE_F_NV"
	_GLenum_map[34089] = "GL_VARIABLE_G_NV"
	_GLenum_map[34090] = "GL_CONSTANT_COLOR0_NV"
	_GLenum_map[34091] = "GL_CONSTANT_COLOR1_NV"
	_GLenum_map[34092] = "GL_PRIMARY_COLOR_NV"
	_GLenum_map[34093] = "GL_SECONDARY_COLOR_NV"
	_GLenum_map[34094] = "GL_SPARE0_NV"
	_GLenum_map[34095] = "GL_SPARE1_NV"
	_GLenum_map[34096] = "GL_DISCARD_NV"
	_GLenum_map[34097] = "GL_E_TIMES_F_NV"
	_GLenum_map[34098] = "GL_SPARE0_PLUS_SECONDARY_COLOR_NV"
	_GLenum_map[34099] = "GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV"
	_GLenum_map[34100] = "GL_MULTISAMPLE_FILTER_HINT_NV"
	_GLenum_map[34101] = "GL_PER_STAGE_CONSTANTS_NV"
	_GLenum_map[34102] = "GL_UNSIGNED_IDENTITY_NV"
	_GLenum_map[34103] = "GL_UNSIGNED_INVERT_NV"
	_GLenum_map[34104] = "GL_EXPAND_NORMAL_NV"
	_GLenum_map[34105] = "GL_EXPAND_NEGATE_NV"
	_GLenum_map[34106] = "GL_HALF_BIAS_NORMAL_NV"
	_GLenum_map[34107] = "GL_HALF_BIAS_NEGATE_NV"
	_GLenum_map[34108] = "GL_SIGNED_IDENTITY_NV"
	_GLenum_map[34109] = "GL_SIGNED_NEGATE_NV"
	_GLenum_map[34110] = "GL_SCALE_BY_TWO_NV"
	_GLenum_map[34111] = "GL_SCALE_BY_FOUR_NV"
	_GLenum_map[34112] = "GL_SCALE_BY_ONE_HALF_NV"
	_GLenum_map[34113] = "GL_BIAS_BY_NEGATIVE_ONE_HALF_NV"
	_GLenum_map[34114] = "GL_COMBINER_INPUT_NV"
	_GLenum_map[34115] = "GL_COMBINER_MAPPING_NV"
	_GLenum_map[34116] = "GL_COMBINER_COMPONENT_USAGE_NV"
	_GLenum_map[34117] = "GL_COMBINER_AB_DOT_PRODUCT_NV"
	_GLenum_map[34118] = "GL_COMBINER_CD_DOT_PRODUCT_NV"
	_GLenum_map[34119] = "GL_COMBINER_MUX_SUM_NV"
	_GLenum_map[34120] = "GL_COMBINER_SCALE_NV"
	_GLenum_map[34121] = "GL_COMBINER_BIAS_NV"
	_GLenum_map[34122] = "GL_COMBINER_AB_OUTPUT_NV"
	_GLenum_map[34123] = "GL_COMBINER_CD_OUTPUT_NV"
	_GLenum_map[34124] = "GL_COMBINER_SUM_OUTPUT_NV"
	_GLenum_map[34125] = "GL_MAX_GENERAL_COMBINERS_NV"
	_GLenum_map[34126] = "GL_NUM_GENERAL_COMBINERS_NV"
	_GLenum_map[34127] = "GL_COLOR_SUM_CLAMP_NV"
	_GLenum_map[34128] = "GL_COMBINER0_NV"
	_GLenum_map[34129] = "GL_COMBINER1_NV"
	_GLenum_map[34130] = "GL_COMBINER2_NV"
	_GLenum_map[34131] = "GL_COMBINER3_NV"
	_GLenum_map[34132] = "GL_COMBINER4_NV"
	_GLenum_map[34133] = "GL_COMBINER5_NV"
	_GLenum_map[34134] = "GL_COMBINER6_NV"
	_GLenum_map[34135] = "GL_COMBINER7_NV"
	_GLenum_map[34136] = "GL_PRIMITIVE_RESTART_NV"
	_GLenum_map[34137] = "GL_PRIMITIVE_RESTART_INDEX_NV"
	_GLenum_map[34138] = "GL_FOG_DISTANCE_MODE_NV"
	_GLenum_map[34139] = "GL_EYE_RADIAL_NV"
	_GLenum_map[34140] = "GL_EYE_PLANE_ABSOLUTE_NV"
	_GLenum_map[34141] = "GL_EMBOSS_LIGHT_NV"
	_GLenum_map[34142] = "GL_EMBOSS_CONSTANT_NV"
	_GLenum_map[34143] = "GL_EMBOSS_MAP_NV"
	_GLenum_map[34144] = "GL_RED_MIN_CLAMP_INGR"
	_GLenum_map[34145] = "GL_GREEN_MIN_CLAMP_INGR"
	_GLenum_map[34146] = "GL_BLUE_MIN_CLAMP_INGR"
	_GLenum_map[34147] = "GL_ALPHA_MIN_CLAMP_INGR"
	_GLenum_map[34148] = "GL_RED_MAX_CLAMP_INGR"
	_GLenum_map[34149] = "GL_GREEN_MAX_CLAMP_INGR"
	_GLenum_map[34150] = "GL_BLUE_MAX_CLAMP_INGR"
	_GLenum_map[34151] = "GL_ALPHA_MAX_CLAMP_INGR"
	_GLenum_map[34152] = "GL_INTERLACE_READ_INGR"
	_GLenum_map[34160] = "GL_COMBINE_ARB"
	_GLenum_map[34160] = "GL_COMBINE"
	_GLenum_map[34160] = "GL_COMBINE_EXT"
	_GLenum_map[34161] = "GL_COMBINE_RGB_ARB"
	_GLenum_map[34161] = "GL_COMBINE_RGB_EXT"
	_GLenum_map[34161] = "GL_COMBINE_RGB"
	_GLenum_map[34162] = "GL_COMBINE_ALPHA_ARB"
	_GLenum_map[34162] = "GL_COMBINE_ALPHA"
	_GLenum_map[34162] = "GL_COMBINE_ALPHA_EXT"
	_GLenum_map[34163] = "GL_RGB_SCALE"
	_GLenum_map[34163] = "GL_RGB_SCALE_EXT"
	_GLenum_map[34163] = "GL_RGB_SCALE_ARB"
	_GLenum_map[34164] = "GL_ADD_SIGNED"
	_GLenum_map[34164] = "GL_ADD_SIGNED_ARB"
	_GLenum_map[34164] = "GL_ADD_SIGNED_EXT"
	_GLenum_map[34165] = "GL_INTERPOLATE_ARB"
	_GLenum_map[34165] = "GL_INTERPOLATE_EXT"
	_GLenum_map[34165] = "GL_INTERPOLATE"
	_GLenum_map[34166] = "GL_CONSTANT_NV"
	_GLenum_map[34166] = "GL_CONSTANT_EXT"
	_GLenum_map[34166] = "GL_CONSTANT_ARB"
	_GLenum_map[34166] = "GL_CONSTANT"
	_GLenum_map[34167] = "GL_PRIMARY_COLOR"
	_GLenum_map[34167] = "GL_PRIMARY_COLOR_EXT"
	_GLenum_map[34167] = "GL_PRIMARY_COLOR_ARB"
	_GLenum_map[34168] = "GL_PREVIOUS_EXT"
	_GLenum_map[34168] = "GL_PREVIOUS_ARB"
	_GLenum_map[34168] = "GL_PREVIOUS"
	_GLenum_map[34176] = "GL_SRC0_RGB"
	_GLenum_map[34176] = "GL_SOURCE0_RGB"
	_GLenum_map[34176] = "GL_SOURCE0_RGB_ARB"
	_GLenum_map[34176] = "GL_SOURCE0_RGB_EXT"
	_GLenum_map[34177] = "GL_SOURCE1_RGB_EXT"
	_GLenum_map[34177] = "GL_SRC1_RGB"
	_GLenum_map[34177] = "GL_SOURCE1_RGB"
	_GLenum_map[34177] = "GL_SOURCE1_RGB_ARB"
	_GLenum_map[34178] = "GL_SOURCE2_RGB_EXT"
	_GLenum_map[34178] = "GL_SRC2_RGB"
	_GLenum_map[34178] = "GL_SOURCE2_RGB_ARB"
	_GLenum_map[34178] = "GL_SOURCE2_RGB"
	_GLenum_map[34179] = "GL_SOURCE3_RGB_NV"
	_GLenum_map[34184] = "GL_SOURCE0_ALPHA"
	_GLenum_map[34184] = "GL_SRC0_ALPHA"
	_GLenum_map[34184] = "GL_SOURCE0_ALPHA_EXT"
	_GLenum_map[34184] = "GL_SOURCE0_ALPHA_ARB"
	_GLenum_map[34185] = "GL_SOURCE1_ALPHA_ARB"
	_GLenum_map[34185] = "GL_SOURCE1_ALPHA_EXT"
	_GLenum_map[34185] = "GL_SOURCE1_ALPHA"
	_GLenum_map[34185] = "GL_SRC1_ALPHA"
	_GLenum_map[34186] = "GL_SOURCE2_ALPHA_ARB"
	_GLenum_map[34186] = "GL_SOURCE2_ALPHA"
	_GLenum_map[34186] = "GL_SRC2_ALPHA"
	_GLenum_map[34186] = "GL_SOURCE2_ALPHA_EXT"
	_GLenum_map[34187] = "GL_SOURCE3_ALPHA_NV"
	_GLenum_map[34192] = "GL_OPERAND0_RGB_EXT"
	_GLenum_map[34192] = "GL_OPERAND0_RGB"
	_GLenum_map[34192] = "GL_OPERAND0_RGB_ARB"
	_GLenum_map[34193] = "GL_OPERAND1_RGB_EXT"
	_GLenum_map[34193] = "GL_OPERAND1_RGB_ARB"
	_GLenum_map[34193] = "GL_OPERAND1_RGB"
	_GLenum_map[34194] = "GL_OPERAND2_RGB"
	_GLenum_map[34194] = "GL_OPERAND2_RGB_EXT"
	_GLenum_map[34194] = "GL_OPERAND2_RGB_ARB"
	_GLenum_map[34195] = "GL_OPERAND3_RGB_NV"
	_GLenum_map[34200] = "GL_OPERAND0_ALPHA"
	_GLenum_map[34200] = "GL_OPERAND0_ALPHA_ARB"
	_GLenum_map[34200] = "GL_OPERAND0_ALPHA_EXT"
	_GLenum_map[34201] = "GL_OPERAND1_ALPHA"
	_GLenum_map[34201] = "GL_OPERAND1_ALPHA_ARB"
	_GLenum_map[34201] = "GL_OPERAND1_ALPHA_EXT"
	_GLenum_map[34202] = "GL_OPERAND2_ALPHA"
	_GLenum_map[34202] = "GL_OPERAND2_ALPHA_ARB"
	_GLenum_map[34202] = "GL_OPERAND2_ALPHA_EXT"
	_GLenum_map[34203] = "GL_OPERAND3_ALPHA_NV"
	_GLenum_map[34208] = "GL_PACK_SUBSAMPLE_RATE_SGIX"
	_GLenum_map[34209] = "GL_UNPACK_SUBSAMPLE_RATE_SGIX"
	_GLenum_map[34210] = "GL_PIXEL_SUBSAMPLE_4444_SGIX"
	_GLenum_map[34211] = "GL_PIXEL_SUBSAMPLE_2424_SGIX"
	_GLenum_map[34212] = "GL_PIXEL_SUBSAMPLE_4242_SGIX"
	_GLenum_map[34222] = "GL_PERTURB_EXT"
	_GLenum_map[34223] = "GL_TEXTURE_NORMAL_EXT"
	_GLenum_map[34224] = "GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE"
	_GLenum_map[34225] = "GL_TRANSFORM_HINT_APPLE"
	_GLenum_map[34226] = "GL_UNPACK_CLIENT_STORAGE_APPLE"
	_GLenum_map[34227] = "GL_BUFFER_OBJECT_APPLE"
	_GLenum_map[34228] = "GL_STORAGE_CLIENT_APPLE"
	_GLenum_map[34229] = "GL_VERTEX_ARRAY_BINDING_OES"
	_GLenum_map[34229] = "GL_VERTEX_ARRAY_BINDING"
	_GLenum_map[34229] = "GL_VERTEX_ARRAY_BINDING_APPLE"
	_GLenum_map[34231] = "GL_TEXTURE_RANGE_LENGTH_APPLE"
	_GLenum_map[34232] = "GL_TEXTURE_RANGE_POINTER_APPLE"
	_GLenum_map[34233] = "GL_YCBCR_422_APPLE"
	_GLenum_map[34234] = "GL_UNSIGNED_SHORT_8_8_MESA"
	_GLenum_map[34234] = "GL_UNSIGNED_SHORT_8_8_APPLE"
	_GLenum_map[34235] = "GL_UNSIGNED_SHORT_8_8_REV_APPLE"
	_GLenum_map[34235] = "GL_UNSIGNED_SHORT_8_8_REV_MESA"
	_GLenum_map[34236] = "GL_TEXTURE_STORAGE_HINT_APPLE"
	_GLenum_map[34237] = "GL_STORAGE_PRIVATE_APPLE"
	_GLenum_map[34238] = "GL_STORAGE_CACHED_APPLE"
	_GLenum_map[34239] = "GL_STORAGE_SHARED_APPLE"
	_GLenum_map[34240] = "GL_REPLACEMENT_CODE_ARRAY_SUN"
	_GLenum_map[34241] = "GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN"
	_GLenum_map[34242] = "GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN"
	_GLenum_map[34243] = "GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN"
	_GLenum_map[34244] = "GL_R1UI_V3F_SUN"
	_GLenum_map[34245] = "GL_R1UI_C4UB_V3F_SUN"
	_GLenum_map[34246] = "GL_R1UI_C3F_V3F_SUN"
	_GLenum_map[34247] = "GL_R1UI_N3F_V3F_SUN"
	_GLenum_map[34248] = "GL_R1UI_C4F_N3F_V3F_SUN"
	_GLenum_map[34249] = "GL_R1UI_T2F_V3F_SUN"
	_GLenum_map[34250] = "GL_R1UI_T2F_N3F_V3F_SUN"
	_GLenum_map[34251] = "GL_R1UI_T2F_C4F_N3F_V3F_SUN"
	_GLenum_map[34252] = "GL_SLICE_ACCUM_SUN"
	_GLenum_map[34324] = "GL_QUAD_MESH_SUN"
	_GLenum_map[34325] = "GL_TRIANGLE_MESH_SUN"
	_GLenum_map[34336] = "GL_VERTEX_PROGRAM_NV"
	_GLenum_map[34336] = "GL_VERTEX_PROGRAM_ARB"
	_GLenum_map[34337] = "GL_VERTEX_STATE_PROGRAM_NV"
	_GLenum_map[34338] = "GL_VERTEX_ATTRIB_ARRAY_ENABLED"
	_GLenum_map[34338] = "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB"
	_GLenum_map[34339] = "GL_VERTEX_ATTRIB_ARRAY_SIZE"
	_GLenum_map[34339] = "GL_ATTRIB_ARRAY_SIZE_NV"
	_GLenum_map[34339] = "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB"
	_GLenum_map[34340] = "GL_ATTRIB_ARRAY_STRIDE_NV"
	_GLenum_map[34340] = "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB"
	_GLenum_map[34340] = "GL_VERTEX_ATTRIB_ARRAY_STRIDE"
	_GLenum_map[34341] = "GL_VERTEX_ATTRIB_ARRAY_TYPE"
	_GLenum_map[34341] = "GL_ATTRIB_ARRAY_TYPE_NV"
	_GLenum_map[34341] = "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB"
	_GLenum_map[34342] = "GL_CURRENT_ATTRIB_NV"
	_GLenum_map[34342] = "GL_CURRENT_VERTEX_ATTRIB_ARB"
	_GLenum_map[34342] = "GL_CURRENT_VERTEX_ATTRIB"
	_GLenum_map[34343] = "GL_PROGRAM_LENGTH_NV"
	_GLenum_map[34343] = "GL_PROGRAM_LENGTH_ARB"
	_GLenum_map[34344] = "GL_PROGRAM_STRING_ARB"
	_GLenum_map[34344] = "GL_PROGRAM_STRING_NV"
	_GLenum_map[34345] = "GL_MODELVIEW_PROJECTION_NV"
	_GLenum_map[34346] = "GL_IDENTITY_NV"
	_GLenum_map[34347] = "GL_INVERSE_NV"
	_GLenum_map[34348] = "GL_TRANSPOSE_NV"
	_GLenum_map[34349] = "GL_INVERSE_TRANSPOSE_NV"
	_GLenum_map[34350] = "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB"
	_GLenum_map[34350] = "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV"
	_GLenum_map[34351] = "GL_MAX_PROGRAM_MATRICES_ARB"
	_GLenum_map[34351] = "GL_MAX_TRACK_MATRICES_NV"
	_GLenum_map[34352] = "GL_MATRIX0_NV"
	_GLenum_map[34353] = "GL_MATRIX1_NV"
	_GLenum_map[34354] = "GL_MATRIX2_NV"
	_GLenum_map[34355] = "GL_MATRIX3_NV"
	_GLenum_map[34356] = "GL_MATRIX4_NV"
	_GLenum_map[34357] = "GL_MATRIX5_NV"
	_GLenum_map[34358] = "GL_MATRIX6_NV"
	_GLenum_map[34359] = "GL_MATRIX7_NV"
	_GLenum_map[34368] = "GL_CURRENT_MATRIX_STACK_DEPTH_NV"
	_GLenum_map[34368] = "GL_CURRENT_MATRIX_STACK_DEPTH_ARB"
	_GLenum_map[34369] = "GL_CURRENT_MATRIX_ARB"
	_GLenum_map[34369] = "GL_CURRENT_MATRIX_NV"
	_GLenum_map[34370] = "GL_VERTEX_PROGRAM_POINT_SIZE_ARB"
	_GLenum_map[34370] = "GL_VERTEX_PROGRAM_POINT_SIZE"
	_GLenum_map[34370] = "GL_VERTEX_PROGRAM_POINT_SIZE_NV"
	_GLenum_map[34370] = "GL_PROGRAM_POINT_SIZE"
	_GLenum_map[34370] = "GL_PROGRAM_POINT_SIZE_ARB"
	_GLenum_map[34370] = "GL_PROGRAM_POINT_SIZE_EXT"
	_GLenum_map[34371] = "GL_VERTEX_PROGRAM_TWO_SIDE"
	_GLenum_map[34371] = "GL_VERTEX_PROGRAM_TWO_SIDE_ARB"
	_GLenum_map[34371] = "GL_VERTEX_PROGRAM_TWO_SIDE_NV"
	_GLenum_map[34372] = "GL_PROGRAM_PARAMETER_NV"
	_GLenum_map[34373] = "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB"
	_GLenum_map[34373] = "GL_ATTRIB_ARRAY_POINTER_NV"
	_GLenum_map[34373] = "GL_VERTEX_ATTRIB_ARRAY_POINTER"
	_GLenum_map[34374] = "GL_PROGRAM_TARGET_NV"
	_GLenum_map[34375] = "GL_PROGRAM_RESIDENT_NV"
	_GLenum_map[34376] = "GL_TRACK_MATRIX_NV"
	_GLenum_map[34377] = "GL_TRACK_MATRIX_TRANSFORM_NV"
	_GLenum_map[34378] = "GL_VERTEX_PROGRAM_BINDING_NV"
	_GLenum_map[34379] = "GL_PROGRAM_ERROR_POSITION_NV"
	_GLenum_map[34379] = "GL_PROGRAM_ERROR_POSITION_ARB"
	_GLenum_map[34380] = "GL_OFFSET_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34381] = "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV"
	_GLenum_map[34382] = "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34383] = "GL_DEPTH_CLAMP_NV"
	_GLenum_map[34383] = "GL_DEPTH_CLAMP"
	_GLenum_map[34384] = "GL_VERTEX_ATTRIB_ARRAY0_NV"
	_GLenum_map[34385] = "GL_VERTEX_ATTRIB_ARRAY1_NV"
	_GLenum_map[34386] = "GL_VERTEX_ATTRIB_ARRAY2_NV"
	_GLenum_map[34387] = "GL_VERTEX_ATTRIB_ARRAY3_NV"
	_GLenum_map[34388] = "GL_VERTEX_ATTRIB_ARRAY4_NV"
	_GLenum_map[34389] = "GL_VERTEX_ATTRIB_ARRAY5_NV"
	_GLenum_map[34390] = "GL_VERTEX_ATTRIB_ARRAY6_NV"
	_GLenum_map[34391] = "GL_VERTEX_ATTRIB_ARRAY7_NV"
	_GLenum_map[34392] = "GL_VERTEX_ATTRIB_ARRAY8_NV"
	_GLenum_map[34393] = "GL_VERTEX_ATTRIB_ARRAY9_NV"
	_GLenum_map[34394] = "GL_VERTEX_ATTRIB_ARRAY10_NV"
	_GLenum_map[34395] = "GL_VERTEX_ATTRIB_ARRAY11_NV"
	_GLenum_map[34396] = "GL_VERTEX_ATTRIB_ARRAY12_NV"
	_GLenum_map[34397] = "GL_VERTEX_ATTRIB_ARRAY13_NV"
	_GLenum_map[34398] = "GL_VERTEX_ATTRIB_ARRAY14_NV"
	_GLenum_map[34399] = "GL_VERTEX_ATTRIB_ARRAY15_NV"
	_GLenum_map[34400] = "GL_MAP1_VERTEX_ATTRIB0_4_NV"
	_GLenum_map[34401] = "GL_MAP1_VERTEX_ATTRIB1_4_NV"
	_GLenum_map[34402] = "GL_MAP1_VERTEX_ATTRIB2_4_NV"
	_GLenum_map[34403] = "GL_MAP1_VERTEX_ATTRIB3_4_NV"
	_GLenum_map[34404] = "GL_MAP1_VERTEX_ATTRIB4_4_NV"
	_GLenum_map[34405] = "GL_MAP1_VERTEX_ATTRIB5_4_NV"
	_GLenum_map[34406] = "GL_MAP1_VERTEX_ATTRIB6_4_NV"
	_GLenum_map[34407] = "GL_MAP1_VERTEX_ATTRIB7_4_NV"
	_GLenum_map[34408] = "GL_MAP1_VERTEX_ATTRIB8_4_NV"
	_GLenum_map[34409] = "GL_MAP1_VERTEX_ATTRIB9_4_NV"
	_GLenum_map[34410] = "GL_MAP1_VERTEX_ATTRIB10_4_NV"
	_GLenum_map[34411] = "GL_MAP1_VERTEX_ATTRIB11_4_NV"
	_GLenum_map[34412] = "GL_MAP1_VERTEX_ATTRIB12_4_NV"
	_GLenum_map[34413] = "GL_MAP1_VERTEX_ATTRIB13_4_NV"
	_GLenum_map[34414] = "GL_MAP1_VERTEX_ATTRIB14_4_NV"
	_GLenum_map[34415] = "GL_MAP1_VERTEX_ATTRIB15_4_NV"
	_GLenum_map[34416] = "GL_MAP2_VERTEX_ATTRIB0_4_NV"
	_GLenum_map[34417] = "GL_MAP2_VERTEX_ATTRIB1_4_NV"
	_GLenum_map[34418] = "GL_MAP2_VERTEX_ATTRIB2_4_NV"
	_GLenum_map[34419] = "GL_MAP2_VERTEX_ATTRIB3_4_NV"
	_GLenum_map[34420] = "GL_MAP2_VERTEX_ATTRIB4_4_NV"
	_GLenum_map[34421] = "GL_MAP2_VERTEX_ATTRIB5_4_NV"
	_GLenum_map[34422] = "GL_MAP2_VERTEX_ATTRIB6_4_NV"
	_GLenum_map[34423] = "GL_MAP2_VERTEX_ATTRIB7_4_NV"
	_GLenum_map[34423] = "GL_PROGRAM_BINDING_ARB"
	_GLenum_map[34424] = "GL_MAP2_VERTEX_ATTRIB8_4_NV"
	_GLenum_map[34425] = "GL_MAP2_VERTEX_ATTRIB9_4_NV"
	_GLenum_map[34426] = "GL_MAP2_VERTEX_ATTRIB10_4_NV"
	_GLenum_map[34427] = "GL_MAP2_VERTEX_ATTRIB11_4_NV"
	_GLenum_map[34428] = "GL_MAP2_VERTEX_ATTRIB12_4_NV"
	_GLenum_map[34429] = "GL_MAP2_VERTEX_ATTRIB13_4_NV"
	_GLenum_map[34430] = "GL_MAP2_VERTEX_ATTRIB14_4_NV"
	_GLenum_map[34431] = "GL_MAP2_VERTEX_ATTRIB15_4_NV"
	_GLenum_map[34464] = "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB"
	_GLenum_map[34464] = "GL_TEXTURE_COMPRESSED_IMAGE_SIZE"
	_GLenum_map[34465] = "GL_TEXTURE_COMPRESSED_ARB"
	_GLenum_map[34465] = "GL_TEXTURE_COMPRESSED"
	_GLenum_map[34466] = "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB"
	_GLenum_map[34466] = "GL_NUM_COMPRESSED_TEXTURE_FORMATS"
	_GLenum_map[34467] = "GL_COMPRESSED_TEXTURE_FORMATS"
	_GLenum_map[34467] = "GL_COMPRESSED_TEXTURE_FORMATS_ARB"
	_GLenum_map[34468] = "GL_MAX_VERTEX_UNITS_ARB"
	_GLenum_map[34468] = "GL_MAX_VERTEX_UNITS_OES"
	_GLenum_map[34469] = "GL_ACTIVE_VERTEX_UNITS_ARB"
	_GLenum_map[34470] = "GL_WEIGHT_SUM_UNITY_ARB"
	_GLenum_map[34471] = "GL_VERTEX_BLEND_ARB"
	_GLenum_map[34472] = "GL_CURRENT_WEIGHT_ARB"
	_GLenum_map[34473] = "GL_WEIGHT_ARRAY_TYPE_OES"
	_GLenum_map[34473] = "GL_WEIGHT_ARRAY_TYPE_ARB"
	_GLenum_map[34474] = "GL_WEIGHT_ARRAY_STRIDE_ARB"
	_GLenum_map[34474] = "GL_WEIGHT_ARRAY_STRIDE_OES"
	_GLenum_map[34475] = "GL_WEIGHT_ARRAY_SIZE_OES"
	_GLenum_map[34475] = "GL_WEIGHT_ARRAY_SIZE_ARB"
	_GLenum_map[34476] = "GL_WEIGHT_ARRAY_POINTER_OES"
	_GLenum_map[34476] = "GL_WEIGHT_ARRAY_POINTER_ARB"
	_GLenum_map[34477] = "GL_WEIGHT_ARRAY_OES"
	_GLenum_map[34477] = "GL_WEIGHT_ARRAY_ARB"
	_GLenum_map[34478] = "GL_DOT3_RGB"
	_GLenum_map[34478] = "GL_DOT3_RGB_ARB"
	_GLenum_map[34479] = "GL_DOT3_RGBA_IMG"
	_GLenum_map[34479] = "GL_DOT3_RGBA"
	_GLenum_map[34479] = "GL_DOT3_RGBA_ARB"
	_GLenum_map[34480] = "GL_COMPRESSED_RGB_FXT1_3DFX"
	_GLenum_map[34481] = "GL_COMPRESSED_RGBA_FXT1_3DFX"
	_GLenum_map[34482] = "GL_MULTISAMPLE_3DFX"
	_GLenum_map[34483] = "GL_SAMPLE_BUFFERS_3DFX"
	_GLenum_map[34484] = "GL_SAMPLES_3DFX"
	_GLenum_map[34496] = "GL_EVAL_2D_NV"
	_GLenum_map[34497] = "GL_EVAL_TRIANGULAR_2D_NV"
	_GLenum_map[34498] = "GL_MAP_TESSELLATION_NV"
	_GLenum_map[34499] = "GL_MAP_ATTRIB_U_ORDER_NV"
	_GLenum_map[34500] = "GL_MAP_ATTRIB_V_ORDER_NV"
	_GLenum_map[34501] = "GL_EVAL_FRACTIONAL_TESSELLATION_NV"
	_GLenum_map[34502] = "GL_EVAL_VERTEX_ATTRIB0_NV"
	_GLenum_map[34503] = "GL_EVAL_VERTEX_ATTRIB1_NV"
	_GLenum_map[34504] = "GL_EVAL_VERTEX_ATTRIB2_NV"
	_GLenum_map[34505] = "GL_EVAL_VERTEX_ATTRIB3_NV"
	_GLenum_map[34506] = "GL_EVAL_VERTEX_ATTRIB4_NV"
	_GLenum_map[34507] = "GL_EVAL_VERTEX_ATTRIB5_NV"
	_GLenum_map[34508] = "GL_EVAL_VERTEX_ATTRIB6_NV"
	_GLenum_map[34509] = "GL_EVAL_VERTEX_ATTRIB7_NV"
	_GLenum_map[34510] = "GL_EVAL_VERTEX_ATTRIB8_NV"
	_GLenum_map[34511] = "GL_EVAL_VERTEX_ATTRIB9_NV"
	_GLenum_map[34512] = "GL_EVAL_VERTEX_ATTRIB10_NV"
	_GLenum_map[34513] = "GL_EVAL_VERTEX_ATTRIB11_NV"
	_GLenum_map[34514] = "GL_EVAL_VERTEX_ATTRIB12_NV"
	_GLenum_map[34515] = "GL_EVAL_VERTEX_ATTRIB13_NV"
	_GLenum_map[34516] = "GL_EVAL_VERTEX_ATTRIB14_NV"
	_GLenum_map[34517] = "GL_EVAL_VERTEX_ATTRIB15_NV"
	_GLenum_map[34518] = "GL_MAX_MAP_TESSELLATION_NV"
	_GLenum_map[34519] = "GL_MAX_RATIONAL_EVAL_ORDER_NV"
	_GLenum_map[34520] = "GL_MAX_PROGRAM_PATCH_ATTRIBS_NV"
	_GLenum_map[34521] = "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV"
	_GLenum_map[34522] = "GL_UNSIGNED_INT_S8_S8_8_8_NV"
	_GLenum_map[34523] = "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV"
	_GLenum_map[34524] = "GL_DSDT_MAG_INTENSITY_NV"
	_GLenum_map[34525] = "GL_SHADER_CONSISTENT_NV"
	_GLenum_map[34526] = "GL_TEXTURE_SHADER_NV"
	_GLenum_map[34527] = "GL_SHADER_OPERATION_NV"
	_GLenum_map[34528] = "GL_CULL_MODES_NV"
	_GLenum_map[34529] = "GL_OFFSET_TEXTURE_MATRIX_NV"
	_GLenum_map[34529] = "GL_OFFSET_TEXTURE_2D_MATRIX_NV"
	_GLenum_map[34530] = "GL_OFFSET_TEXTURE_2D_SCALE_NV"
	_GLenum_map[34530] = "GL_OFFSET_TEXTURE_SCALE_NV"
	_GLenum_map[34531] = "GL_OFFSET_TEXTURE_2D_BIAS_NV"
	_GLenum_map[34531] = "GL_OFFSET_TEXTURE_BIAS_NV"
	_GLenum_map[34532] = "GL_PREVIOUS_TEXTURE_INPUT_NV"
	_GLenum_map[34533] = "GL_CONST_EYE_NV"
	_GLenum_map[34534] = "GL_PASS_THROUGH_NV"
	_GLenum_map[34535] = "GL_CULL_FRAGMENT_NV"
	_GLenum_map[34536] = "GL_OFFSET_TEXTURE_2D_NV"
	_GLenum_map[34537] = "GL_DEPENDENT_AR_TEXTURE_2D_NV"
	_GLenum_map[34538] = "GL_DEPENDENT_GB_TEXTURE_2D_NV"
	_GLenum_map[34539] = "GL_SURFACE_STATE_NV"
	_GLenum_map[34540] = "GL_DOT_PRODUCT_NV"
	_GLenum_map[34541] = "GL_DOT_PRODUCT_DEPTH_REPLACE_NV"
	_GLenum_map[34542] = "GL_DOT_PRODUCT_TEXTURE_2D_NV"
	_GLenum_map[34543] = "GL_DOT_PRODUCT_TEXTURE_3D_NV"
	_GLenum_map[34544] = "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV"
	_GLenum_map[34545] = "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV"
	_GLenum_map[34546] = "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV"
	_GLenum_map[34547] = "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV"
	_GLenum_map[34548] = "GL_HILO_NV"
	_GLenum_map[34549] = "GL_DSDT_NV"
	_GLenum_map[34550] = "GL_DSDT_MAG_NV"
	_GLenum_map[34551] = "GL_DSDT_MAG_VIB_NV"
	_GLenum_map[34552] = "GL_HILO16_NV"
	_GLenum_map[34553] = "GL_SIGNED_HILO_NV"
	_GLenum_map[34554] = "GL_SIGNED_HILO16_NV"
	_GLenum_map[34555] = "GL_SIGNED_RGBA_NV"
	_GLenum_map[34556] = "GL_SIGNED_RGBA8_NV"
	_GLenum_map[34557] = "GL_SURFACE_REGISTERED_NV"
	_GLenum_map[34558] = "GL_SIGNED_RGB_NV"
	_GLenum_map[34559] = "GL_SIGNED_RGB8_NV"
	_GLenum_map[34560] = "GL_SURFACE_MAPPED_NV"
	_GLenum_map[34561] = "GL_SIGNED_LUMINANCE_NV"
	_GLenum_map[34562] = "GL_SIGNED_LUMINANCE8_NV"
	_GLenum_map[34563] = "GL_SIGNED_LUMINANCE_ALPHA_NV"
	_GLenum_map[34564] = "GL_SIGNED_LUMINANCE8_ALPHA8_NV"
	_GLenum_map[34565] = "GL_SIGNED_ALPHA_NV"
	_GLenum_map[34566] = "GL_SIGNED_ALPHA8_NV"
	_GLenum_map[34567] = "GL_SIGNED_INTENSITY_NV"
	_GLenum_map[34568] = "GL_SIGNED_INTENSITY8_NV"
	_GLenum_map[34569] = "GL_DSDT8_NV"
	_GLenum_map[34570] = "GL_DSDT8_MAG8_NV"
	_GLenum_map[34571] = "GL_DSDT8_MAG8_INTENSITY8_NV"
	_GLenum_map[34572] = "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV"
	_GLenum_map[34573] = "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV"
	_GLenum_map[34574] = "GL_HI_SCALE_NV"
	_GLenum_map[34575] = "GL_LO_SCALE_NV"
	_GLenum_map[34576] = "GL_DS_SCALE_NV"
	_GLenum_map[34577] = "GL_DT_SCALE_NV"
	_GLenum_map[34578] = "GL_MAGNITUDE_SCALE_NV"
	_GLenum_map[34579] = "GL_VIBRANCE_SCALE_NV"
	_GLenum_map[34580] = "GL_HI_BIAS_NV"
	_GLenum_map[34581] = "GL_LO_BIAS_NV"
	_GLenum_map[34582] = "GL_DS_BIAS_NV"
	_GLenum_map[34583] = "GL_DT_BIAS_NV"
	_GLenum_map[34584] = "GL_MAGNITUDE_BIAS_NV"
	_GLenum_map[34585] = "GL_VIBRANCE_BIAS_NV"
	_GLenum_map[34586] = "GL_TEXTURE_BORDER_VALUES_NV"
	_GLenum_map[34587] = "GL_TEXTURE_HI_SIZE_NV"
	_GLenum_map[34588] = "GL_TEXTURE_LO_SIZE_NV"
	_GLenum_map[34589] = "GL_TEXTURE_DS_SIZE_NV"
	_GLenum_map[34590] = "GL_TEXTURE_DT_SIZE_NV"
	_GLenum_map[34591] = "GL_TEXTURE_MAG_SIZE_NV"
	_GLenum_map[34594] = "GL_MODELVIEW2_ARB"
	_GLenum_map[34595] = "GL_MODELVIEW3_ARB"
	_GLenum_map[34596] = "GL_MODELVIEW4_ARB"
	_GLenum_map[34597] = "GL_MODELVIEW5_ARB"
	_GLenum_map[34598] = "GL_MODELVIEW6_ARB"
	_GLenum_map[34599] = "GL_MODELVIEW7_ARB"
	_GLenum_map[34600] = "GL_MODELVIEW8_ARB"
	_GLenum_map[34601] = "GL_MODELVIEW9_ARB"
	_GLenum_map[34602] = "GL_MODELVIEW10_ARB"
	_GLenum_map[34603] = "GL_MODELVIEW11_ARB"
	_GLenum_map[34604] = "GL_MODELVIEW12_ARB"
	_GLenum_map[34605] = "GL_MODELVIEW13_ARB"
	_GLenum_map[34606] = "GL_MODELVIEW14_ARB"
	_GLenum_map[34607] = "GL_MODELVIEW15_ARB"
	_GLenum_map[34608] = "GL_MODELVIEW16_ARB"
	_GLenum_map[34609] = "GL_MODELVIEW17_ARB"
	_GLenum_map[34610] = "GL_MODELVIEW18_ARB"
	_GLenum_map[34611] = "GL_MODELVIEW19_ARB"
	_GLenum_map[34612] = "GL_MODELVIEW20_ARB"
	_GLenum_map[34613] = "GL_MODELVIEW21_ARB"
	_GLenum_map[34614] = "GL_MODELVIEW22_ARB"
	_GLenum_map[34615] = "GL_MODELVIEW23_ARB"
	_GLenum_map[34616] = "GL_MODELVIEW24_ARB"
	_GLenum_map[34617] = "GL_MODELVIEW25_ARB"
	_GLenum_map[34618] = "GL_MODELVIEW26_ARB"
	_GLenum_map[34619] = "GL_MODELVIEW27_ARB"
	_GLenum_map[34620] = "GL_MODELVIEW28_ARB"
	_GLenum_map[34621] = "GL_MODELVIEW29_ARB"
	_GLenum_map[34622] = "GL_MODELVIEW30_ARB"
	_GLenum_map[34623] = "GL_MODELVIEW31_ARB"
	_GLenum_map[34624] = "GL_Z400_BINARY_AMD"
	_GLenum_map[34624] = "GL_DOT3_RGB_EXT"
	_GLenum_map[34625] = "GL_DOT3_RGBA_EXT"
	_GLenum_map[34625] = "GL_PROGRAM_BINARY_LENGTH"
	_GLenum_map[34625] = "GL_PROGRAM_BINARY_LENGTH_OES"
	_GLenum_map[34626] = "GL_MIRROR_CLAMP_EXT"
	_GLenum_map[34626] = "GL_MIRROR_CLAMP_ATI"
	_GLenum_map[34627] = "GL_MIRROR_CLAMP_TO_EDGE"
	_GLenum_map[34627] = "GL_MIRROR_CLAMP_TO_EDGE_ATI"
	_GLenum_map[34627] = "GL_MIRROR_CLAMP_TO_EDGE_EXT"
	_GLenum_map[34628] = "GL_MODULATE_ADD_ATI"
	_GLenum_map[34629] = "GL_MODULATE_SIGNED_ADD_ATI"
	_GLenum_map[34630] = "GL_MODULATE_SUBTRACT_ATI"
	_GLenum_map[34634] = "GL_SET_AMD"
	_GLenum_map[34635] = "GL_REPLACE_VALUE_AMD"
	_GLenum_map[34636] = "GL_STENCIL_OP_VALUE_AMD"
	_GLenum_map[34637] = "GL_STENCIL_BACK_OP_VALUE_AMD"
	_GLenum_map[34638] = "GL_VERTEX_ATTRIB_ARRAY_LONG"
	_GLenum_map[34639] = "GL_OCCLUSION_QUERY_EVENT_MASK_AMD"
	_GLenum_map[34640] = "GL_DEPTH_STENCIL_MESA"
	_GLenum_map[34641] = "GL_UNSIGNED_INT_24_8_MESA"
	_GLenum_map[34642] = "GL_UNSIGNED_INT_8_24_REV_MESA"
	_GLenum_map[34643] = "GL_UNSIGNED_SHORT_15_1_MESA"
	_GLenum_map[34644] = "GL_UNSIGNED_SHORT_1_15_REV_MESA"
	_GLenum_map[34645] = "GL_TRACE_MASK_MESA"
	_GLenum_map[34646] = "GL_TRACE_NAME_MESA"
	_GLenum_map[34647] = "GL_YCBCR_MESA"
	_GLenum_map[34648] = "GL_PACK_INVERT_MESA"
	_GLenum_map[34649] = "GL_DEBUG_OBJECT_MESA"
	_GLenum_map[34649] = "GL_TEXTURE_1D_STACK_MESAX"
	_GLenum_map[34650] = "GL_DEBUG_PRINT_MESA"
	_GLenum_map[34650] = "GL_TEXTURE_2D_STACK_MESAX"
	_GLenum_map[34651] = "GL_DEBUG_ASSERT_MESA"
	_GLenum_map[34651] = "GL_PROXY_TEXTURE_1D_STACK_MESAX"
	_GLenum_map[34652] = "GL_PROXY_TEXTURE_2D_STACK_MESAX"
	_GLenum_map[34653] = "GL_TEXTURE_1D_STACK_BINDING_MESAX"
	_GLenum_map[34654] = "GL_TEXTURE_2D_STACK_BINDING_MESAX"
	_GLenum_map[34656] = "GL_STATIC_ATI"
	_GLenum_map[34657] = "GL_DYNAMIC_ATI"
	_GLenum_map[34658] = "GL_PRESERVE_ATI"
	_GLenum_map[34659] = "GL_DISCARD_ATI"
	_GLenum_map[34660] = "GL_BUFFER_SIZE_ARB"
	_GLenum_map[34660] = "GL_BUFFER_SIZE"
	_GLenum_map[34660] = "GL_OBJECT_BUFFER_SIZE_ATI"
	_GLenum_map[34661] = "GL_BUFFER_USAGE"
	_GLenum_map[34661] = "GL_BUFFER_USAGE_ARB"
	_GLenum_map[34661] = "GL_OBJECT_BUFFER_USAGE_ATI"
	_GLenum_map[34662] = "GL_ARRAY_OBJECT_BUFFER_ATI"
	_GLenum_map[34663] = "GL_ARRAY_OBJECT_OFFSET_ATI"
	_GLenum_map[34664] = "GL_ELEMENT_ARRAY_ATI"
	_GLenum_map[34665] = "GL_ELEMENT_ARRAY_TYPE_ATI"
	_GLenum_map[34666] = "GL_ELEMENT_ARRAY_POINTER_ATI"
	_GLenum_map[34667] = "GL_MAX_VERTEX_STREAMS_ATI"
	_GLenum_map[34668] = "GL_VERTEX_STREAM0_ATI"
	_GLenum_map[34669] = "GL_VERTEX_STREAM1_ATI"
	_GLenum_map[34670] = "GL_VERTEX_STREAM2_ATI"
	_GLenum_map[34671] = "GL_VERTEX_STREAM3_ATI"
	_GLenum_map[34672] = "GL_VERTEX_STREAM4_ATI"
	_GLenum_map[34673] = "GL_VERTEX_STREAM5_ATI"
	_GLenum_map[34674] = "GL_VERTEX_STREAM6_ATI"
	_GLenum_map[34675] = "GL_VERTEX_STREAM7_ATI"
	_GLenum_map[34676] = "GL_VERTEX_SOURCE_ATI"
	_GLenum_map[34677] = "GL_BUMP_ROT_MATRIX_ATI"
	_GLenum_map[34678] = "GL_BUMP_ROT_MATRIX_SIZE_ATI"
	_GLenum_map[34679] = "GL_BUMP_NUM_TEX_UNITS_ATI"
	_GLenum_map[34680] = "GL_BUMP_TEX_UNITS_ATI"
	_GLenum_map[34681] = "GL_DUDV_ATI"
	_GLenum_map[34682] = "GL_DU8DV8_ATI"
	_GLenum_map[34683] = "GL_BUMP_ENVMAP_ATI"
	_GLenum_map[34684] = "GL_BUMP_TARGET_ATI"
	_GLenum_map[34688] = "GL_VERTEX_SHADER_EXT"
	_GLenum_map[34689] = "GL_VERTEX_SHADER_BINDING_EXT"
	_GLenum_map[34690] = "GL_OP_INDEX_EXT"
	_GLenum_map[34691] = "GL_OP_NEGATE_EXT"
	_GLenum_map[34692] = "GL_OP_DOT3_EXT"
	_GLenum_map[34693] = "GL_OP_DOT4_EXT"
	_GLenum_map[34694] = "GL_OP_MUL_EXT"
	_GLenum_map[34695] = "GL_OP_ADD_EXT"
	_GLenum_map[34696] = "GL_OP_MADD_EXT"
	_GLenum_map[34697] = "GL_OP_FRAC_EXT"
	_GLenum_map[34698] = "GL_OP_MAX_EXT"
	_GLenum_map[34699] = "GL_OP_MIN_EXT"
	_GLenum_map[34700] = "GL_OP_SET_GE_EXT"
	_GLenum_map[34701] = "GL_OP_SET_LT_EXT"
	_GLenum_map[34702] = "GL_OP_CLAMP_EXT"
	_GLenum_map[34703] = "GL_OP_FLOOR_EXT"
	_GLenum_map[34704] = "GL_OP_ROUND_EXT"
	_GLenum_map[34705] = "GL_OP_EXP_BASE_2_EXT"
	_GLenum_map[34706] = "GL_OP_LOG_BASE_2_EXT"
	_GLenum_map[34707] = "GL_OP_POWER_EXT"
	_GLenum_map[34708] = "GL_OP_RECIP_EXT"
	_GLenum_map[34709] = "GL_OP_RECIP_SQRT_EXT"
	_GLenum_map[34710] = "GL_OP_SUB_EXT"
	_GLenum_map[34711] = "GL_OP_CROSS_PRODUCT_EXT"
	_GLenum_map[34712] = "GL_OP_MULTIPLY_MATRIX_EXT"
	_GLenum_map[34713] = "GL_OP_MOV_EXT"
	_GLenum_map[34714] = "GL_OUTPUT_VERTEX_EXT"
	_GLenum_map[34715] = "GL_OUTPUT_COLOR0_EXT"
	_GLenum_map[34716] = "GL_OUTPUT_COLOR1_EXT"
	_GLenum_map[34717] = "GL_OUTPUT_TEXTURE_COORD0_EXT"
	_GLenum_map[34718] = "GL_OUTPUT_TEXTURE_COORD1_EXT"
	_GLenum_map[34719] = "GL_OUTPUT_TEXTURE_COORD2_EXT"
	_GLenum_map[34720] = "GL_OUTPUT_TEXTURE_COORD3_EXT"
	_GLenum_map[34721] = "GL_OUTPUT_TEXTURE_COORD4_EXT"
	_GLenum_map[34722] = "GL_OUTPUT_TEXTURE_COORD5_EXT"
	_GLenum_map[34723] = "GL_OUTPUT_TEXTURE_COORD6_EXT"
	_GLenum_map[34724] = "GL_OUTPUT_TEXTURE_COORD7_EXT"
	_GLenum_map[34725] = "GL_OUTPUT_TEXTURE_COORD8_EXT"
	_GLenum_map[34726] = "GL_OUTPUT_TEXTURE_COORD9_EXT"
	_GLenum_map[34727] = "GL_OUTPUT_TEXTURE_COORD10_EXT"
	_GLenum_map[34728] = "GL_OUTPUT_TEXTURE_COORD11_EXT"
	_GLenum_map[34729] = "GL_OUTPUT_TEXTURE_COORD12_EXT"
	_GLenum_map[34730] = "GL_OUTPUT_TEXTURE_COORD13_EXT"
	_GLenum_map[34731] = "GL_OUTPUT_TEXTURE_COORD14_EXT"
	_GLenum_map[34732] = "GL_OUTPUT_TEXTURE_COORD15_EXT"
	_GLenum_map[34733] = "GL_OUTPUT_TEXTURE_COORD16_EXT"
	_GLenum_map[34734] = "GL_OUTPUT_TEXTURE_COORD17_EXT"
	_GLenum_map[34735] = "GL_OUTPUT_TEXTURE_COORD18_EXT"
	_GLenum_map[34736] = "GL_OUTPUT_TEXTURE_COORD19_EXT"
	_GLenum_map[34737] = "GL_OUTPUT_TEXTURE_COORD20_EXT"
	_GLenum_map[34738] = "GL_OUTPUT_TEXTURE_COORD21_EXT"
	_GLenum_map[34739] = "GL_OUTPUT_TEXTURE_COORD22_EXT"
	_GLenum_map[34740] = "GL_OUTPUT_TEXTURE_COORD23_EXT"
	_GLenum_map[34741] = "GL_OUTPUT_TEXTURE_COORD24_EXT"
	_GLenum_map[34742] = "GL_OUTPUT_TEXTURE_COORD25_EXT"
	_GLenum_map[34743] = "GL_OUTPUT_TEXTURE_COORD26_EXT"
	_GLenum_map[34744] = "GL_OUTPUT_TEXTURE_COORD27_EXT"
	_GLenum_map[34745] = "GL_OUTPUT_TEXTURE_COORD28_EXT"
	_GLenum_map[34746] = "GL_OUTPUT_TEXTURE_COORD29_EXT"
	_GLenum_map[34747] = "GL_OUTPUT_TEXTURE_COORD30_EXT"
	_GLenum_map[34748] = "GL_OUTPUT_TEXTURE_COORD31_EXT"
	_GLenum_map[34749] = "GL_OUTPUT_FOG_EXT"
	_GLenum_map[34750] = "GL_SCALAR_EXT"
	_GLenum_map[34751] = "GL_VECTOR_EXT"
	_GLenum_map[34752] = "GL_MATRIX_EXT"
	_GLenum_map[34753] = "GL_VARIANT_EXT"
	_GLenum_map[34754] = "GL_INVARIANT_EXT"
	_GLenum_map[34755] = "GL_LOCAL_CONSTANT_EXT"
	_GLenum_map[34756] = "GL_LOCAL_EXT"
	_GLenum_map[34757] = "GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT"
	_GLenum_map[34758] = "GL_MAX_VERTEX_SHADER_VARIANTS_EXT"
	_GLenum_map[34759] = "GL_MAX_VERTEX_SHADER_INVARIANTS_EXT"
	_GLenum_map[34760] = "GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT"
	_GLenum_map[34761] = "GL_MAX_VERTEX_SHADER_LOCALS_EXT"
	_GLenum_map[34762] = "GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT"
	_GLenum_map[34763] = "GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT"
	_GLenum_map[34764] = "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT"
	_GLenum_map[34765] = "GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT"
	_GLenum_map[34766] = "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT"
	_GLenum_map[34767] = "GL_VERTEX_SHADER_INSTRUCTIONS_EXT"
	_GLenum_map[34768] = "GL_VERTEX_SHADER_VARIANTS_EXT"
	_GLenum_map[34769] = "GL_VERTEX_SHADER_INVARIANTS_EXT"
	_GLenum_map[34770] = "GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT"
	_GLenum_map[34771] = "GL_VERTEX_SHADER_LOCALS_EXT"
	_GLenum_map[34772] = "GL_VERTEX_SHADER_OPTIMIZED_EXT"
	_GLenum_map[34773] = "GL_X_EXT"
	_GLenum_map[34774] = "GL_Y_EXT"
	_GLenum_map[34775] = "GL_Z_EXT"
	_GLenum_map[34776] = "GL_W_EXT"
	_GLenum_map[34777] = "GL_NEGATIVE_X_EXT"
	_GLenum_map[34778] = "GL_NEGATIVE_Y_EXT"
	_GLenum_map[34779] = "GL_NEGATIVE_Z_EXT"
	_GLenum_map[34780] = "GL_NEGATIVE_W_EXT"
	_GLenum_map[34781] = "GL_ZERO_EXT"
	_GLenum_map[34782] = "GL_ONE_EXT"
	_GLenum_map[34783] = "GL_NEGATIVE_ONE_EXT"
	_GLenum_map[34784] = "GL_NORMALIZED_RANGE_EXT"
	_GLenum_map[34785] = "GL_FULL_RANGE_EXT"
	_GLenum_map[34786] = "GL_CURRENT_VERTEX_EXT"
	_GLenum_map[34787] = "GL_MVP_MATRIX_EXT"
	_GLenum_map[34788] = "GL_VARIANT_VALUE_EXT"
	_GLenum_map[34789] = "GL_VARIANT_DATATYPE_EXT"
	_GLenum_map[34790] = "GL_VARIANT_ARRAY_STRIDE_EXT"
	_GLenum_map[34791] = "GL_VARIANT_ARRAY_TYPE_EXT"
	_GLenum_map[34792] = "GL_VARIANT_ARRAY_EXT"
	_GLenum_map[34793] = "GL_VARIANT_ARRAY_POINTER_EXT"
	_GLenum_map[34794] = "GL_INVARIANT_VALUE_EXT"
	_GLenum_map[34795] = "GL_INVARIANT_DATATYPE_EXT"
	_GLenum_map[34796] = "GL_LOCAL_CONSTANT_VALUE_EXT"
	_GLenum_map[34797] = "GL_LOCAL_CONSTANT_DATATYPE_EXT"
	_GLenum_map[34798] = "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD"
	_GLenum_map[34800] = "GL_PN_TRIANGLES_ATI"
	_GLenum_map[34801] = "GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI"
	_GLenum_map[34802] = "GL_PN_TRIANGLES_POINT_MODE_ATI"
	_GLenum_map[34803] = "GL_PN_TRIANGLES_NORMAL_MODE_ATI"
	_GLenum_map[34804] = "GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI"
	_GLenum_map[34805] = "GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI"
	_GLenum_map[34806] = "GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI"
	_GLenum_map[34807] = "GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI"
	_GLenum_map[34808] = "GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI"
	_GLenum_map[34809] = "GL_3DC_X_AMD"
	_GLenum_map[34810] = "GL_3DC_XY_AMD"
	_GLenum_map[34811] = "GL_VBO_FREE_MEMORY_ATI"
	_GLenum_map[34812] = "GL_TEXTURE_FREE_MEMORY_ATI"
	_GLenum_map[34813] = "GL_RENDERBUFFER_FREE_MEMORY_ATI"
	_GLenum_map[34814] = "GL_NUM_PROGRAM_BINARY_FORMATS_OES"
	_GLenum_map[34814] = "GL_NUM_PROGRAM_BINARY_FORMATS"
	_GLenum_map[34815] = "GL_PROGRAM_BINARY_FORMATS_OES"
	_GLenum_map[34815] = "GL_PROGRAM_BINARY_FORMATS"
	_GLenum_map[34816] = "GL_STENCIL_BACK_FUNC"
	_GLenum_map[34816] = "GL_STENCIL_BACK_FUNC_ATI"
	_GLenum_map[34817] = "GL_STENCIL_BACK_FAIL"
	_GLenum_map[34817] = "GL_STENCIL_BACK_FAIL_ATI"
	_GLenum_map[34818] = "GL_STENCIL_BACK_PASS_DEPTH_FAIL"
	_GLenum_map[34818] = "GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI"
	_GLenum_map[34819] = "GL_STENCIL_BACK_PASS_DEPTH_PASS"
	_GLenum_map[34819] = "GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI"
	_GLenum_map[34820] = "GL_FRAGMENT_PROGRAM_ARB"
	_GLenum_map[34821] = "GL_PROGRAM_ALU_INSTRUCTIONS_ARB"
	_GLenum_map[34822] = "GL_PROGRAM_TEX_INSTRUCTIONS_ARB"
	_GLenum_map[34823] = "GL_PROGRAM_TEX_INDIRECTIONS_ARB"
	_GLenum_map[34824] = "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB"
	_GLenum_map[34825] = "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB"
	_GLenum_map[34826] = "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB"
	_GLenum_map[34827] = "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB"
	_GLenum_map[34828] = "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB"
	_GLenum_map[34829] = "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB"
	_GLenum_map[34830] = "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB"
	_GLenum_map[34831] = "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB"
	_GLenum_map[34832] = "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB"
	_GLenum_map[34836] = "GL_RGBA32F_ARB"
	_GLenum_map[34836] = "GL_RGBA_FLOAT32_ATI"
	_GLenum_map[34836] = "GL_RGBA_FLOAT32_APPLE"
	_GLenum_map[34836] = "GL_RGBA32F_EXT"
	_GLenum_map[34836] = "GL_RGBA32F"
	_GLenum_map[34837] = "GL_RGB32F_ARB"
	_GLenum_map[34837] = "GL_RGB_FLOAT32_ATI"
	_GLenum_map[34837] = "GL_RGB_FLOAT32_APPLE"
	_GLenum_map[34837] = "GL_RGB32F_EXT"
	_GLenum_map[34837] = "GL_RGB32F"
	_GLenum_map[34838] = "GL_ALPHA_FLOAT32_ATI"
	_GLenum_map[34838] = "GL_ALPHA_FLOAT32_APPLE"
	_GLenum_map[34838] = "GL_ALPHA32F_ARB"
	_GLenum_map[34838] = "GL_ALPHA32F_EXT"
	_GLenum_map[34839] = "GL_INTENSITY32F_ARB"
	_GLenum_map[34839] = "GL_INTENSITY_FLOAT32_APPLE"
	_GLenum_map[34839] = "GL_INTENSITY_FLOAT32_ATI"
	_GLenum_map[34840] = "GL_LUMINANCE32F_EXT"
	_GLenum_map[34840] = "GL_LUMINANCE_FLOAT32_APPLE"
	_GLenum_map[34840] = "GL_LUMINANCE_FLOAT32_ATI"
	_GLenum_map[34840] = "GL_LUMINANCE32F_ARB"
	_GLenum_map[34841] = "GL_LUMINANCE_ALPHA_FLOAT32_ATI"
	_GLenum_map[34841] = "GL_LUMINANCE_ALPHA32F_ARB"
	_GLenum_map[34841] = "GL_LUMINANCE_ALPHA32F_EXT"
	_GLenum_map[34841] = "GL_LUMINANCE_ALPHA_FLOAT32_APPLE"
	_GLenum_map[34842] = "GL_RGBA16F_EXT"
	_GLenum_map[34842] = "GL_RGBA16F_ARB"
	_GLenum_map[34842] = "GL_RGBA16F"
	_GLenum_map[34842] = "GL_RGBA_FLOAT16_ATI"
	_GLenum_map[34842] = "GL_RGBA_FLOAT16_APPLE"
	_GLenum_map[34843] = "GL_RGB_FLOAT16_APPLE"
	_GLenum_map[34843] = "GL_RGB_FLOAT16_ATI"
	_GLenum_map[34843] = "GL_RGB16F"
	_GLenum_map[34843] = "GL_RGB16F_ARB"
	_GLenum_map[34843] = "GL_RGB16F_EXT"
	_GLenum_map[34844] = "GL_ALPHA16F_EXT"
	_GLenum_map[34844] = "GL_ALPHA_FLOAT16_APPLE"
	_GLenum_map[34844] = "GL_ALPHA_FLOAT16_ATI"
	_GLenum_map[34844] = "GL_ALPHA16F_ARB"
	_GLenum_map[34845] = "GL_INTENSITY_FLOAT16_ATI"
	_GLenum_map[34845] = "GL_INTENSITY16F_ARB"
	_GLenum_map[34845] = "GL_INTENSITY_FLOAT16_APPLE"
	_GLenum_map[34846] = "GL_LUMINANCE16F_EXT"
	_GLenum_map[34846] = "GL_LUMINANCE_FLOAT16_ATI"
	_GLenum_map[34846] = "GL_LUMINANCE16F_ARB"
	_GLenum_map[34846] = "GL_LUMINANCE_FLOAT16_APPLE"
	_GLenum_map[34847] = "GL_LUMINANCE_ALPHA16F_EXT"
	_GLenum_map[34847] = "GL_LUMINANCE_ALPHA16F_ARB"
	_GLenum_map[34847] = "GL_LUMINANCE_ALPHA_FLOAT16_APPLE"
	_GLenum_map[34847] = "GL_LUMINANCE_ALPHA_FLOAT16_ATI"
	_GLenum_map[34848] = "GL_RGBA_FLOAT_MODE_ARB"
	_GLenum_map[34848] = "GL_RGBA_FLOAT_MODE_ATI"
	_GLenum_map[34851] = "GL_WRITEONLY_RENDERING_QCOM"
	_GLenum_map[34852] = "GL_MAX_DRAW_BUFFERS"
	_GLenum_map[34852] = "GL_MAX_DRAW_BUFFERS_ATI"
	_GLenum_map[34852] = "GL_MAX_DRAW_BUFFERS_NV"
	_GLenum_map[34852] = "GL_MAX_DRAW_BUFFERS_ARB"
	_GLenum_map[34852] = "GL_MAX_DRAW_BUFFERS_EXT"
	_GLenum_map[34853] = "GL_DRAW_BUFFER0_EXT"
	_GLenum_map[34853] = "GL_DRAW_BUFFER0_ATI"
	_GLenum_map[34853] = "GL_DRAW_BUFFER0_NV"
	_GLenum_map[34853] = "GL_DRAW_BUFFER0"
	_GLenum_map[34853] = "GL_DRAW_BUFFER0_ARB"
	_GLenum_map[34854] = "GL_DRAW_BUFFER1_NV"
	_GLenum_map[34854] = "GL_DRAW_BUFFER1_EXT"
	_GLenum_map[34854] = "GL_DRAW_BUFFER1_ATI"
	_GLenum_map[34854] = "GL_DRAW_BUFFER1_ARB"
	_GLenum_map[34854] = "GL_DRAW_BUFFER1"
	_GLenum_map[34855] = "GL_DRAW_BUFFER2"
	_GLenum_map[34855] = "GL_DRAW_BUFFER2_NV"
	_GLenum_map[34855] = "GL_DRAW_BUFFER2_EXT"
	_GLenum_map[34855] = "GL_DRAW_BUFFER2_ATI"
	_GLenum_map[34855] = "GL_DRAW_BUFFER2_ARB"
	_GLenum_map[34856] = "GL_DRAW_BUFFER3_EXT"
	_GLenum_map[34856] = "GL_DRAW_BUFFER3_ATI"
	_GLenum_map[34856] = "GL_DRAW_BUFFER3_NV"
	_GLenum_map[34856] = "GL_DRAW_BUFFER3_ARB"
	_GLenum_map[34856] = "GL_DRAW_BUFFER3"
	_GLenum_map[34857] = "GL_DRAW_BUFFER4_EXT"
	_GLenum_map[34857] = "GL_DRAW_BUFFER4_NV"
	_GLenum_map[34857] = "GL_DRAW_BUFFER4_ATI"
	_GLenum_map[34857] = "GL_DRAW_BUFFER4_ARB"
	_GLenum_map[34857] = "GL_DRAW_BUFFER4"
	_GLenum_map[34858] = "GL_DRAW_BUFFER5_ATI"
	_GLenum_map[34858] = "GL_DRAW_BUFFER5"
	_GLenum_map[34858] = "GL_DRAW_BUFFER5_ARB"
	_GLenum_map[34858] = "GL_DRAW_BUFFER5_NV"
	_GLenum_map[34858] = "GL_DRAW_BUFFER5_EXT"
	_GLenum_map[34859] = "GL_DRAW_BUFFER6_ATI"
	_GLenum_map[34859] = "GL_DRAW_BUFFER6"
	_GLenum_map[34859] = "GL_DRAW_BUFFER6_ARB"
	_GLenum_map[34859] = "GL_DRAW_BUFFER6_EXT"
	_GLenum_map[34859] = "GL_DRAW_BUFFER6_NV"
	_GLenum_map[34860] = "GL_DRAW_BUFFER7_ATI"
	_GLenum_map[34860] = "GL_DRAW_BUFFER7_ARB"
	_GLenum_map[34860] = "GL_DRAW_BUFFER7"
	_GLenum_map[34860] = "GL_DRAW_BUFFER7_NV"
	_GLenum_map[34860] = "GL_DRAW_BUFFER7_EXT"
	_GLenum_map[34861] = "GL_DRAW_BUFFER8_ATI"
	_GLenum_map[34861] = "GL_DRAW_BUFFER8"
	_GLenum_map[34861] = "GL_DRAW_BUFFER8_ARB"
	_GLenum_map[34861] = "GL_DRAW_BUFFER8_EXT"
	_GLenum_map[34861] = "GL_DRAW_BUFFER8_NV"
	_GLenum_map[34862] = "GL_DRAW_BUFFER9_ATI"
	_GLenum_map[34862] = "GL_DRAW_BUFFER9"
	_GLenum_map[34862] = "GL_DRAW_BUFFER9_EXT"
	_GLenum_map[34862] = "GL_DRAW_BUFFER9_ARB"
	_GLenum_map[34862] = "GL_DRAW_BUFFER9_NV"
	_GLenum_map[34863] = "GL_DRAW_BUFFER10_ARB"
	_GLenum_map[34863] = "GL_DRAW_BUFFER10_EXT"
	_GLenum_map[34863] = "GL_DRAW_BUFFER10_ATI"
	_GLenum_map[34863] = "GL_DRAW_BUFFER10"
	_GLenum_map[34863] = "GL_DRAW_BUFFER10_NV"
	_GLenum_map[34864] = "GL_DRAW_BUFFER11_ARB"
	_GLenum_map[34864] = "GL_DRAW_BUFFER11_EXT"
	_GLenum_map[34864] = "GL_DRAW_BUFFER11_ATI"
	_GLenum_map[34864] = "GL_DRAW_BUFFER11_NV"
	_GLenum_map[34864] = "GL_DRAW_BUFFER11"
	_GLenum_map[34865] = "GL_DRAW_BUFFER12_ATI"
	_GLenum_map[34865] = "GL_DRAW_BUFFER12_ARB"
	_GLenum_map[34865] = "GL_DRAW_BUFFER12"
	_GLenum_map[34865] = "GL_DRAW_BUFFER12_EXT"
	_GLenum_map[34865] = "GL_DRAW_BUFFER12_NV"
	_GLenum_map[34866] = "GL_DRAW_BUFFER13_ARB"
	_GLenum_map[34866] = "GL_DRAW_BUFFER13_EXT"
	_GLenum_map[34866] = "GL_DRAW_BUFFER13"
	_GLenum_map[34866] = "GL_DRAW_BUFFER13_NV"
	_GLenum_map[34866] = "GL_DRAW_BUFFER13_ATI"
	_GLenum_map[34867] = "GL_DRAW_BUFFER14_ATI"
	_GLenum_map[34867] = "GL_DRAW_BUFFER14"
	_GLenum_map[34867] = "GL_DRAW_BUFFER14_ARB"
	_GLenum_map[34867] = "GL_DRAW_BUFFER14_EXT"
	_GLenum_map[34867] = "GL_DRAW_BUFFER14_NV"
	_GLenum_map[34868] = "GL_DRAW_BUFFER15"
	_GLenum_map[34868] = "GL_DRAW_BUFFER15_ARB"
	_GLenum_map[34868] = "GL_DRAW_BUFFER15_EXT"
	_GLenum_map[34868] = "GL_DRAW_BUFFER15_NV"
	_GLenum_map[34868] = "GL_DRAW_BUFFER15_ATI"
	_GLenum_map[34869] = "GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI"
	_GLenum_map[34871] = "GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI"
	_GLenum_map[34877] = "GL_BLEND_EQUATION_ALPHA"
	_GLenum_map[34877] = "GL_BLEND_EQUATION_ALPHA_OES"
	_GLenum_map[34877] = "GL_BLEND_EQUATION_ALPHA_EXT"
	_GLenum_map[34879] = "GL_SUBSAMPLE_DISTANCE_AMD"
	_GLenum_map[34880] = "GL_MATRIX_PALETTE_ARB"
	_GLenum_map[34880] = "GL_MATRIX_PALETTE_OES"
	_GLenum_map[34881] = "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB"
	_GLenum_map[34882] = "GL_MAX_PALETTE_MATRICES_ARB"
	_GLenum_map[34882] = "GL_MAX_PALETTE_MATRICES_OES"
	_GLenum_map[34883] = "GL_CURRENT_PALETTE_MATRIX_ARB"
	_GLenum_map[34883] = "GL_CURRENT_PALETTE_MATRIX_OES"
	_GLenum_map[34884] = "GL_MATRIX_INDEX_ARRAY_OES"
	_GLenum_map[34884] = "GL_MATRIX_INDEX_ARRAY_ARB"
	_GLenum_map[34885] = "GL_CURRENT_MATRIX_INDEX_ARB"
	_GLenum_map[34886] = "GL_MATRIX_INDEX_ARRAY_SIZE_ARB"
	_GLenum_map[34886] = "GL_MATRIX_INDEX_ARRAY_SIZE_OES"
	_GLenum_map[34887] = "GL_MATRIX_INDEX_ARRAY_TYPE_OES"
	_GLenum_map[34887] = "GL_MATRIX_INDEX_ARRAY_TYPE_ARB"
	_GLenum_map[34888] = "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB"
	_GLenum_map[34888] = "GL_MATRIX_INDEX_ARRAY_STRIDE_OES"
	_GLenum_map[34889] = "GL_MATRIX_INDEX_ARRAY_POINTER_OES"
	_GLenum_map[34889] = "GL_MATRIX_INDEX_ARRAY_POINTER_ARB"
	_GLenum_map[34890] = "GL_TEXTURE_DEPTH_SIZE"
	_GLenum_map[34890] = "GL_TEXTURE_DEPTH_SIZE_ARB"
	_GLenum_map[34891] = "GL_DEPTH_TEXTURE_MODE_ARB"
	_GLenum_map[34891] = "GL_DEPTH_TEXTURE_MODE"
	_GLenum_map[34892] = "GL_TEXTURE_COMPARE_MODE"
	_GLenum_map[34892] = "GL_TEXTURE_COMPARE_MODE_ARB"
	_GLenum_map[34892] = "GL_TEXTURE_COMPARE_MODE_EXT"
	_GLenum_map[34893] = "GL_TEXTURE_COMPARE_FUNC"
	_GLenum_map[34893] = "GL_TEXTURE_COMPARE_FUNC_EXT"
	_GLenum_map[34893] = "GL_TEXTURE_COMPARE_FUNC_ARB"
	_GLenum_map[34894] = "GL_COMPARE_REF_TO_TEXTURE"
	_GLenum_map[34894] = "GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT"
	_GLenum_map[34894] = "GL_COMPARE_REF_TO_TEXTURE_EXT"
	_GLenum_map[34894] = "GL_COMPARE_R_TO_TEXTURE"
	_GLenum_map[34894] = "GL_COMPARE_R_TO_TEXTURE_ARB"
	_GLenum_map[34895] = "GL_TEXTURE_CUBE_MAP_SEAMLESS"
	_GLenum_map[34896] = "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV"
	_GLenum_map[34897] = "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV"
	_GLenum_map[34898] = "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34899] = "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV"
	_GLenum_map[34900] = "GL_OFFSET_HILO_TEXTURE_2D_NV"
	_GLenum_map[34901] = "GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34902] = "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV"
	_GLenum_map[34903] = "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV"
	_GLenum_map[34904] = "GL_DEPENDENT_HILO_TEXTURE_2D_NV"
	_GLenum_map[34905] = "GL_DEPENDENT_RGB_TEXTURE_3D_NV"
	_GLenum_map[34906] = "GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV"
	_GLenum_map[34907] = "GL_DOT_PRODUCT_PASS_THROUGH_NV"
	_GLenum_map[34908] = "GL_DOT_PRODUCT_TEXTURE_1D_NV"
	_GLenum_map[34909] = "GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV"
	_GLenum_map[34910] = "GL_HILO8_NV"
	_GLenum_map[34911] = "GL_SIGNED_HILO8_NV"
	_GLenum_map[34912] = "GL_FORCE_BLUE_TO_ONE_NV"
	_GLenum_map[34913] = "GL_POINT_SPRITE_OES"
	_GLenum_map[34913] = "GL_POINT_SPRITE_ARB"
	_GLenum_map[34913] = "GL_POINT_SPRITE"
	_GLenum_map[34913] = "GL_POINT_SPRITE_NV"
	_GLenum_map[34914] = "GL_COORD_REPLACE_ARB"
	_GLenum_map[34914] = "GL_COORD_REPLACE_OES"
	_GLenum_map[34914] = "GL_COORD_REPLACE"
	_GLenum_map[34914] = "GL_COORD_REPLACE_NV"
	_GLenum_map[34915] = "GL_POINT_SPRITE_R_MODE_NV"
	_GLenum_map[34916] = "GL_PIXEL_COUNTER_BITS_NV"
	_GLenum_map[34916] = "GL_QUERY_COUNTER_BITS_ARB"
	_GLenum_map[34916] = "GL_QUERY_COUNTER_BITS_EXT"
	_GLenum_map[34916] = "GL_QUERY_COUNTER_BITS"
	_GLenum_map[34917] = "GL_CURRENT_OCCLUSION_QUERY_ID_NV"
	_GLenum_map[34917] = "GL_CURRENT_QUERY"
	_GLenum_map[34917] = "GL_CURRENT_QUERY_ARB"
	_GLenum_map[34917] = "GL_CURRENT_QUERY_EXT"
	_GLenum_map[34918] = "GL_QUERY_RESULT_ARB"
	_GLenum_map[34918] = "GL_QUERY_RESULT"
	_GLenum_map[34918] = "GL_PIXEL_COUNT_NV"
	_GLenum_map[34918] = "GL_QUERY_RESULT_EXT"
	_GLenum_map[34919] = "GL_PIXEL_COUNT_AVAILABLE_NV"
	_GLenum_map[34919] = "GL_QUERY_RESULT_AVAILABLE_ARB"
	_GLenum_map[34919] = "GL_QUERY_RESULT_AVAILABLE_EXT"
	_GLenum_map[34919] = "GL_QUERY_RESULT_AVAILABLE"
	_GLenum_map[34920] = "GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV"
	_GLenum_map[34921] = "GL_MAX_VERTEX_ATTRIBS"
	_GLenum_map[34921] = "GL_MAX_VERTEX_ATTRIBS_ARB"
	_GLenum_map[34922] = "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB"
	_GLenum_map[34922] = "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"
	_GLenum_map[34924] = "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT"
	_GLenum_map[34924] = "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES"
	_GLenum_map[34924] = "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS"
	_GLenum_map[34925] = "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES"
	_GLenum_map[34925] = "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT"
	_GLenum_map[34925] = "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS"
	_GLenum_map[34926] = "GL_DEPTH_STENCIL_TO_RGBA_NV"
	_GLenum_map[34927] = "GL_DEPTH_STENCIL_TO_BGRA_NV"
	_GLenum_map[34928] = "GL_FRAGMENT_PROGRAM_NV"
	_GLenum_map[34929] = "GL_MAX_TEXTURE_COORDS"
	_GLenum_map[34929] = "GL_MAX_TEXTURE_COORDS_ARB"
	_GLenum_map[34929] = "GL_MAX_TEXTURE_COORDS_NV"
	_GLenum_map[34930] = "GL_MAX_TEXTURE_IMAGE_UNITS"
	_GLenum_map[34930] = "GL_MAX_TEXTURE_IMAGE_UNITS_NV"
	_GLenum_map[34930] = "GL_MAX_TEXTURE_IMAGE_UNITS_ARB"
	_GLenum_map[34931] = "GL_FRAGMENT_PROGRAM_BINDING_NV"
	_GLenum_map[34932] = "GL_PROGRAM_ERROR_STRING_ARB"
	_GLenum_map[34932] = "GL_PROGRAM_ERROR_STRING_NV"
	_GLenum_map[34933] = "GL_PROGRAM_FORMAT_ASCII_ARB"
	_GLenum_map[34934] = "GL_PROGRAM_FORMAT_ARB"
	_GLenum_map[34936] = "GL_WRITE_PIXEL_DATA_RANGE_NV"
	_GLenum_map[34937] = "GL_READ_PIXEL_DATA_RANGE_NV"
	_GLenum_map[34938] = "GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV"
	_GLenum_map[34939] = "GL_READ_PIXEL_DATA_RANGE_LENGTH_NV"
	_GLenum_map[34940] = "GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV"
	_GLenum_map[34941] = "GL_READ_PIXEL_DATA_RANGE_POINTER_NV"
	_GLenum_map[34943] = "GL_GEOMETRY_SHADER_INVOCATIONS_OES"
	_GLenum_map[34943] = "GL_GEOMETRY_SHADER_INVOCATIONS"
	_GLenum_map[34943] = "GL_GEOMETRY_SHADER_INVOCATIONS_EXT"
	_GLenum_map[34944] = "GL_FLOAT_R_NV"
	_GLenum_map[34945] = "GL_FLOAT_RG_NV"
	_GLenum_map[34946] = "GL_FLOAT_RGB_NV"
	_GLenum_map[34947] = "GL_FLOAT_RGBA_NV"
	_GLenum_map[34948] = "GL_FLOAT_R16_NV"
	_GLenum_map[34949] = "GL_FLOAT_R32_NV"
	_GLenum_map[34950] = "GL_FLOAT_RG16_NV"
	_GLenum_map[34951] = "GL_FLOAT_RG32_NV"
	_GLenum_map[34952] = "GL_FLOAT_RGB16_NV"
	_GLenum_map[34953] = "GL_FLOAT_RGB32_NV"
	_GLenum_map[34954] = "GL_FLOAT_RGBA16_NV"
	_GLenum_map[34955] = "GL_FLOAT_RGBA32_NV"
	_GLenum_map[34956] = "GL_TEXTURE_FLOAT_COMPONENTS_NV"
	_GLenum_map[34957] = "GL_FLOAT_CLEAR_COLOR_VALUE_NV"
	_GLenum_map[34958] = "GL_FLOAT_RGBA_MODE_NV"
	_GLenum_map[34959] = "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV"
	_GLenum_map[34960] = "GL_DEPTH_BOUNDS_TEST_EXT"
	_GLenum_map[34961] = "GL_DEPTH_BOUNDS_EXT"
	_GLenum_map[34962] = "GL_ARRAY_BUFFER_ARB"
	_GLenum_map[34962] = "GL_ARRAY_BUFFER"
	_GLenum_map[34963] = "GL_ELEMENT_ARRAY_BUFFER_ARB"
	_GLenum_map[34963] = "GL_ELEMENT_ARRAY_BUFFER"
	_GLenum_map[34964] = "GL_ARRAY_BUFFER_BINDING"
	_GLenum_map[34964] = "GL_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34965] = "GL_ELEMENT_ARRAY_BUFFER_BINDING"
	_GLenum_map[34965] = "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34966] = "GL_VERTEX_ARRAY_BUFFER_BINDING"
	_GLenum_map[34966] = "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34967] = "GL_NORMAL_ARRAY_BUFFER_BINDING"
	_GLenum_map[34967] = "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34968] = "GL_COLOR_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34968] = "GL_COLOR_ARRAY_BUFFER_BINDING"
	_GLenum_map[34969] = "GL_INDEX_ARRAY_BUFFER_BINDING"
	_GLenum_map[34969] = "GL_INDEX_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34970] = "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34970] = "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING"
	_GLenum_map[34971] = "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING"
	_GLenum_map[34971] = "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34972] = "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING"
	_GLenum_map[34972] = "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34973] = "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34973] = "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING"
	_GLenum_map[34973] = "GL_FOG_COORD_ARRAY_BUFFER_BINDING"
	_GLenum_map[34974] = "GL_WEIGHT_ARRAY_BUFFER_BINDING_OES"
	_GLenum_map[34974] = "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34974] = "GL_WEIGHT_ARRAY_BUFFER_BINDING"
	_GLenum_map[34975] = "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"
	_GLenum_map[34975] = "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB"
	_GLenum_map[34976] = "GL_PROGRAM_INSTRUCTIONS_ARB"
	_GLenum_map[34977] = "GL_MAX_PROGRAM_INSTRUCTIONS_ARB"
	_GLenum_map[34978] = "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB"
	_GLenum_map[34979] = "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB"
	_GLenum_map[34980] = "GL_PROGRAM_TEMPORARIES_ARB"
	_GLenum_map[34981] = "GL_MAX_PROGRAM_TEMPORARIES_ARB"
	_GLenum_map[34982] = "GL_PROGRAM_NATIVE_TEMPORARIES_ARB"
	_GLenum_map[34983] = "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB"
	_GLenum_map[34984] = "GL_PROGRAM_PARAMETERS_ARB"
	_GLenum_map[34985] = "GL_MAX_PROGRAM_PARAMETERS_ARB"
	_GLenum_map[34986] = "GL_PROGRAM_NATIVE_PARAMETERS_ARB"
	_GLenum_map[34987] = "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB"
	_GLenum_map[34988] = "GL_PROGRAM_ATTRIBS_ARB"
	_GLenum_map[34989] = "GL_MAX_PROGRAM_ATTRIBS_ARB"
	_GLenum_map[34990] = "GL_PROGRAM_NATIVE_ATTRIBS_ARB"
	_GLenum_map[34991] = "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB"
	_GLenum_map[34992] = "GL_PROGRAM_ADDRESS_REGISTERS_ARB"
	_GLenum_map[34993] = "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB"
	_GLenum_map[34994] = "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB"
	_GLenum_map[34995] = "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB"
	_GLenum_map[34996] = "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB"
	_GLenum_map[34997] = "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB"
	_GLenum_map[34998] = "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB"
	_GLenum_map[34999] = "GL_TRANSPOSE_CURRENT_MATRIX_ARB"
	_GLenum_map[35000] = "GL_READ_ONLY_ARB"
	_GLenum_map[35000] = "GL_READ_ONLY"
	_GLenum_map[35001] = "GL_WRITE_ONLY"
	_GLenum_map[35001] = "GL_WRITE_ONLY_ARB"
	_GLenum_map[35001] = "GL_WRITE_ONLY_OES"
	_GLenum_map[35002] = "GL_READ_WRITE_ARB"
	_GLenum_map[35002] = "GL_READ_WRITE"
	_GLenum_map[35003] = "GL_BUFFER_ACCESS_ARB"
	_GLenum_map[35003] = "GL_BUFFER_ACCESS_OES"
	_GLenum_map[35003] = "GL_BUFFER_ACCESS"
	_GLenum_map[35004] = "GL_BUFFER_MAPPED"
	_GLenum_map[35004] = "GL_BUFFER_MAPPED_ARB"
	_GLenum_map[35004] = "GL_BUFFER_MAPPED_OES"
	_GLenum_map[35005] = "GL_BUFFER_MAP_POINTER_OES"
	_GLenum_map[35005] = "GL_BUFFER_MAP_POINTER"
	_GLenum_map[35005] = "GL_BUFFER_MAP_POINTER_ARB"
	_GLenum_map[35006] = "GL_WRITE_DISCARD_NV"
	_GLenum_map[35007] = "GL_TIME_ELAPSED"
	_GLenum_map[35007] = "GL_TIME_ELAPSED_EXT"
	_GLenum_map[35008] = "GL_MATRIX0_ARB"
	_GLenum_map[35009] = "GL_MATRIX1_ARB"
	_GLenum_map[35010] = "GL_MATRIX2_ARB"
	_GLenum_map[35011] = "GL_MATRIX3_ARB"
	_GLenum_map[35012] = "GL_MATRIX4_ARB"
	_GLenum_map[35013] = "GL_MATRIX5_ARB"
	_GLenum_map[35014] = "GL_MATRIX6_ARB"
	_GLenum_map[35015] = "GL_MATRIX7_ARB"
	_GLenum_map[35016] = "GL_MATRIX8_ARB"
	_GLenum_map[35017] = "GL_MATRIX9_ARB"
	_GLenum_map[35018] = "GL_MATRIX10_ARB"
	_GLenum_map[35019] = "GL_MATRIX11_ARB"
	_GLenum_map[35020] = "GL_MATRIX12_ARB"
	_GLenum_map[35021] = "GL_MATRIX13_ARB"
	_GLenum_map[35022] = "GL_MATRIX14_ARB"
	_GLenum_map[35023] = "GL_MATRIX15_ARB"
	_GLenum_map[35024] = "GL_MATRIX16_ARB"
	_GLenum_map[35025] = "GL_MATRIX17_ARB"
	_GLenum_map[35026] = "GL_MATRIX18_ARB"
	_GLenum_map[35027] = "GL_MATRIX19_ARB"
	_GLenum_map[35028] = "GL_MATRIX20_ARB"
	_GLenum_map[35029] = "GL_MATRIX21_ARB"
	_GLenum_map[35030] = "GL_MATRIX22_ARB"
	_GLenum_map[35031] = "GL_MATRIX23_ARB"
	_GLenum_map[35032] = "GL_MATRIX24_ARB"
	_GLenum_map[35033] = "GL_MATRIX25_ARB"
	_GLenum_map[35034] = "GL_MATRIX26_ARB"
	_GLenum_map[35035] = "GL_MATRIX27_ARB"
	_GLenum_map[35036] = "GL_MATRIX28_ARB"
	_GLenum_map[35037] = "GL_MATRIX29_ARB"
	_GLenum_map[35038] = "GL_MATRIX30_ARB"
	_GLenum_map[35039] = "GL_MATRIX31_ARB"
	_GLenum_map[35040] = "GL_STREAM_DRAW_ARB"
	_GLenum_map[35040] = "GL_STREAM_DRAW"
	_GLenum_map[35041] = "GL_STREAM_READ"
	_GLenum_map[35041] = "GL_STREAM_READ_ARB"
	_GLenum_map[35042] = "GL_STREAM_COPY"
	_GLenum_map[35042] = "GL_STREAM_COPY_ARB"
	_GLenum_map[35044] = "GL_STATIC_DRAW"
	_GLenum_map[35044] = "GL_STATIC_DRAW_ARB"
	_GLenum_map[35045] = "GL_STATIC_READ_ARB"
	_GLenum_map[35045] = "GL_STATIC_READ"
	_GLenum_map[35046] = "GL_STATIC_COPY_ARB"
	_GLenum_map[35046] = "GL_STATIC_COPY"
	_GLenum_map[35048] = "GL_DYNAMIC_DRAW_ARB"
	_GLenum_map[35048] = "GL_DYNAMIC_DRAW"
	_GLenum_map[35049] = "GL_DYNAMIC_READ_ARB"
	_GLenum_map[35049] = "GL_DYNAMIC_READ"
	_GLenum_map[35050] = "GL_DYNAMIC_COPY_ARB"
	_GLenum_map[35050] = "GL_DYNAMIC_COPY"
	_GLenum_map[35051] = "GL_PIXEL_PACK_BUFFER_ARB"
	_GLenum_map[35051] = "GL_PIXEL_PACK_BUFFER"
	_GLenum_map[35051] = "GL_PIXEL_PACK_BUFFER_EXT"
	_GLenum_map[35052] = "GL_PIXEL_UNPACK_BUFFER_EXT"
	_GLenum_map[35052] = "GL_PIXEL_UNPACK_BUFFER_ARB"
	_GLenum_map[35052] = "GL_PIXEL_UNPACK_BUFFER"
	_GLenum_map[35053] = "GL_PIXEL_PACK_BUFFER_BINDING_EXT"
	_GLenum_map[35053] = "GL_PIXEL_PACK_BUFFER_BINDING"
	_GLenum_map[35053] = "GL_PIXEL_PACK_BUFFER_BINDING_ARB"
	_GLenum_map[35054] = "GL_ETC1_SRGB8_NV"
	_GLenum_map[35055] = "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT"
	_GLenum_map[35055] = "GL_PIXEL_UNPACK_BUFFER_BINDING_ARB"
	_GLenum_map[35055] = "GL_PIXEL_UNPACK_BUFFER_BINDING"
	_GLenum_map[35056] = "GL_DEPTH24_STENCIL8_OES"
	_GLenum_map[35056] = "GL_DEPTH24_STENCIL8"
	_GLenum_map[35056] = "GL_DEPTH24_STENCIL8_EXT"
	_GLenum_map[35057] = "GL_TEXTURE_STENCIL_SIZE_EXT"
	_GLenum_map[35057] = "GL_TEXTURE_STENCIL_SIZE"
	_GLenum_map[35058] = "GL_STENCIL_TAG_BITS_EXT"
	_GLenum_map[35059] = "GL_STENCIL_CLEAR_TAG_VALUE_EXT"
	_GLenum_map[35060] = "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV"
	_GLenum_map[35061] = "GL_MAX_PROGRAM_CALL_DEPTH_NV"
	_GLenum_map[35062] = "GL_MAX_PROGRAM_IF_DEPTH_NV"
	_GLenum_map[35063] = "GL_MAX_PROGRAM_LOOP_DEPTH_NV"
	_GLenum_map[35064] = "GL_MAX_PROGRAM_LOOP_COUNT_NV"
	_GLenum_map[35065] = "GL_SRC1_COLOR"
	_GLenum_map[35066] = "GL_ONE_MINUS_SRC1_COLOR"
	_GLenum_map[35067] = "GL_ONE_MINUS_SRC1_ALPHA"
	_GLenum_map[35068] = "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS"
	_GLenum_map[35069] = "GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV"
	_GLenum_map[35069] = "GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT"
	_GLenum_map[35069] = "GL_VERTEX_ATTRIB_ARRAY_INTEGER"
	_GLenum_map[35070] = "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE"
	_GLenum_map[35070] = "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB"
	_GLenum_map[35070] = "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV"
	_GLenum_map[35070] = "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"
	_GLenum_map[35070] = "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT"
	_GLenum_map[35071] = "GL_MAX_ARRAY_TEXTURE_LAYERS"
	_GLenum_map[35071] = "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT"
	_GLenum_map[35076] = "GL_MIN_PROGRAM_TEXEL_OFFSET"
	_GLenum_map[35076] = "GL_MIN_PROGRAM_TEXEL_OFFSET_EXT"
	_GLenum_map[35076] = "GL_MIN_PROGRAM_TEXEL_OFFSET_NV"
	_GLenum_map[35077] = "GL_MAX_PROGRAM_TEXEL_OFFSET_NV"
	_GLenum_map[35077] = "GL_MAX_PROGRAM_TEXEL_OFFSET"
	_GLenum_map[35077] = "GL_MAX_PROGRAM_TEXEL_OFFSET_EXT"
	_GLenum_map[35078] = "GL_PROGRAM_ATTRIB_COMPONENTS_NV"
	_GLenum_map[35079] = "GL_PROGRAM_RESULT_COMPONENTS_NV"
	_GLenum_map[35080] = "GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV"
	_GLenum_map[35081] = "GL_MAX_PROGRAM_RESULT_COMPONENTS_NV"
	_GLenum_map[35088] = "GL_STENCIL_TEST_TWO_SIDE_EXT"
	_GLenum_map[35089] = "GL_ACTIVE_STENCIL_FACE_EXT"
	_GLenum_map[35090] = "GL_MIRROR_CLAMP_TO_BORDER_EXT"
	_GLenum_map[35092] = "GL_SAMPLES_PASSED"
	_GLenum_map[35092] = "GL_SAMPLES_PASSED_ARB"
	_GLenum_map[35094] = "GL_GEOMETRY_VERTICES_OUT"
	_GLenum_map[35094] = "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT"
	_GLenum_map[35094] = "GL_GEOMETRY_LINKED_VERTICES_OUT_OES"
	_GLenum_map[35095] = "GL_GEOMETRY_INPUT_TYPE"
	_GLenum_map[35095] = "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT"
	_GLenum_map[35095] = "GL_GEOMETRY_LINKED_INPUT_TYPE_OES"
	_GLenum_map[35096] = "GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES"
	_GLenum_map[35096] = "GL_GEOMETRY_OUTPUT_TYPE"
	_GLenum_map[35096] = "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT"
	_GLenum_map[35097] = "GL_SAMPLER_BINDING"
	_GLenum_map[35098] = "GL_CLAMP_VERTEX_COLOR_ARB"
	_GLenum_map[35098] = "GL_CLAMP_VERTEX_COLOR"
	_GLenum_map[35099] = "GL_CLAMP_FRAGMENT_COLOR"
	_GLenum_map[35099] = "GL_CLAMP_FRAGMENT_COLOR_ARB"
	_GLenum_map[35100] = "GL_CLAMP_READ_COLOR_ARB"
	_GLenum_map[35100] = "GL_CLAMP_READ_COLOR"
	_GLenum_map[35101] = "GL_FIXED_ONLY_ARB"
	_GLenum_map[35101] = "GL_FIXED_ONLY"
	_GLenum_map[35102] = "GL_TESS_CONTROL_PROGRAM_NV"
	_GLenum_map[35103] = "GL_TESS_EVALUATION_PROGRAM_NV"
	_GLenum_map[35104] = "GL_FRAGMENT_SHADER_ATI"
	_GLenum_map[35105] = "GL_REG_0_ATI"
	_GLenum_map[35106] = "GL_REG_1_ATI"
	_GLenum_map[35107] = "GL_REG_2_ATI"
	_GLenum_map[35108] = "GL_REG_3_ATI"
	_GLenum_map[35109] = "GL_REG_4_ATI"
	_GLenum_map[35110] = "GL_REG_5_ATI"
	_GLenum_map[35111] = "GL_REG_6_ATI"
	_GLenum_map[35112] = "GL_REG_7_ATI"
	_GLenum_map[35113] = "GL_REG_8_ATI"
	_GLenum_map[35114] = "GL_REG_9_ATI"
	_GLenum_map[35115] = "GL_REG_10_ATI"
	_GLenum_map[35116] = "GL_REG_11_ATI"
	_GLenum_map[35117] = "GL_REG_12_ATI"
	_GLenum_map[35118] = "GL_REG_13_ATI"
	_GLenum_map[35119] = "GL_REG_14_ATI"
	_GLenum_map[35120] = "GL_REG_15_ATI"
	_GLenum_map[35121] = "GL_REG_16_ATI"
	_GLenum_map[35122] = "GL_REG_17_ATI"
	_GLenum_map[35123] = "GL_REG_18_ATI"
	_GLenum_map[35124] = "GL_REG_19_ATI"
	_GLenum_map[35125] = "GL_REG_20_ATI"
	_GLenum_map[35126] = "GL_REG_21_ATI"
	_GLenum_map[35127] = "GL_REG_22_ATI"
	_GLenum_map[35128] = "GL_REG_23_ATI"
	_GLenum_map[35129] = "GL_REG_24_ATI"
	_GLenum_map[35130] = "GL_REG_25_ATI"
	_GLenum_map[35131] = "GL_REG_26_ATI"
	_GLenum_map[35132] = "GL_REG_27_ATI"
	_GLenum_map[35133] = "GL_REG_28_ATI"
	_GLenum_map[35134] = "GL_REG_29_ATI"
	_GLenum_map[35135] = "GL_REG_30_ATI"
	_GLenum_map[35136] = "GL_REG_31_ATI"
	_GLenum_map[35137] = "GL_CON_0_ATI"
	_GLenum_map[35138] = "GL_CON_1_ATI"
	_GLenum_map[35139] = "GL_CON_2_ATI"
	_GLenum_map[35140] = "GL_CON_3_ATI"
	_GLenum_map[35141] = "GL_CON_4_ATI"
	_GLenum_map[35142] = "GL_CON_5_ATI"
	_GLenum_map[35143] = "GL_CON_6_ATI"
	_GLenum_map[35144] = "GL_CON_7_ATI"
	_GLenum_map[35145] = "GL_CON_8_ATI"
	_GLenum_map[35146] = "GL_CON_9_ATI"
	_GLenum_map[35147] = "GL_CON_10_ATI"
	_GLenum_map[35148] = "GL_CON_11_ATI"
	_GLenum_map[35149] = "GL_CON_12_ATI"
	_GLenum_map[35150] = "GL_CON_13_ATI"
	_GLenum_map[35151] = "GL_CON_14_ATI"
	_GLenum_map[35152] = "GL_CON_15_ATI"
	_GLenum_map[35153] = "GL_CON_16_ATI"
	_GLenum_map[35154] = "GL_CON_17_ATI"
	_GLenum_map[35155] = "GL_CON_18_ATI"
	_GLenum_map[35156] = "GL_CON_19_ATI"
	_GLenum_map[35157] = "GL_CON_20_ATI"
	_GLenum_map[35158] = "GL_CON_21_ATI"
	_GLenum_map[35159] = "GL_CON_22_ATI"
	_GLenum_map[35160] = "GL_CON_23_ATI"
	_GLenum_map[35161] = "GL_CON_24_ATI"
	_GLenum_map[35162] = "GL_CON_25_ATI"
	_GLenum_map[35163] = "GL_CON_26_ATI"
	_GLenum_map[35164] = "GL_CON_27_ATI"
	_GLenum_map[35165] = "GL_CON_28_ATI"
	_GLenum_map[35166] = "GL_CON_29_ATI"
	_GLenum_map[35167] = "GL_CON_30_ATI"
	_GLenum_map[35168] = "GL_CON_31_ATI"
	_GLenum_map[35169] = "GL_MOV_ATI"
	_GLenum_map[35171] = "GL_ADD_ATI"
	_GLenum_map[35172] = "GL_MUL_ATI"
	_GLenum_map[35173] = "GL_SUB_ATI"
	_GLenum_map[35174] = "GL_DOT3_ATI"
	_GLenum_map[35175] = "GL_DOT4_ATI"
	_GLenum_map[35176] = "GL_MAD_ATI"
	_GLenum_map[35177] = "GL_LERP_ATI"
	_GLenum_map[35178] = "GL_CND_ATI"
	_GLenum_map[35179] = "GL_CND0_ATI"
	_GLenum_map[35180] = "GL_DOT2_ADD_ATI"
	_GLenum_map[35181] = "GL_SECONDARY_INTERPOLATOR_ATI"
	_GLenum_map[35182] = "GL_NUM_FRAGMENT_REGISTERS_ATI"
	_GLenum_map[35183] = "GL_NUM_FRAGMENT_CONSTANTS_ATI"
	_GLenum_map[35184] = "GL_NUM_PASSES_ATI"
	_GLenum_map[35185] = "GL_NUM_INSTRUCTIONS_PER_PASS_ATI"
	_GLenum_map[35186] = "GL_NUM_INSTRUCTIONS_TOTAL_ATI"
	_GLenum_map[35187] = "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI"
	_GLenum_map[35188] = "GL_NUM_LOOPBACK_COMPONENTS_ATI"
	_GLenum_map[35189] = "GL_COLOR_ALPHA_PAIRING_ATI"
	_GLenum_map[35190] = "GL_SWIZZLE_STR_ATI"
	_GLenum_map[35191] = "GL_SWIZZLE_STQ_ATI"
	_GLenum_map[35192] = "GL_SWIZZLE_STR_DR_ATI"
	_GLenum_map[35193] = "GL_SWIZZLE_STQ_DQ_ATI"
	_GLenum_map[35194] = "GL_SWIZZLE_STRQ_ATI"
	_GLenum_map[35195] = "GL_SWIZZLE_STRQ_DQ_ATI"
	_GLenum_map[35200] = "GL_INTERLACE_OML"
	_GLenum_map[35201] = "GL_INTERLACE_READ_OML"
	_GLenum_map[35202] = "GL_FORMAT_SUBSAMPLE_24_24_OML"
	_GLenum_map[35203] = "GL_FORMAT_SUBSAMPLE_244_244_OML"
	_GLenum_map[35204] = "GL_PACK_RESAMPLE_OML"
	_GLenum_map[35205] = "GL_UNPACK_RESAMPLE_OML"
	_GLenum_map[35206] = "GL_RESAMPLE_REPLICATE_OML"
	_GLenum_map[35207] = "GL_RESAMPLE_ZERO_FILL_OML"
	_GLenum_map[35208] = "GL_RESAMPLE_AVERAGE_OML"
	_GLenum_map[35209] = "GL_RESAMPLE_DECIMATE_OML"
	_GLenum_map[35210] = "GL_POINT_SIZE_ARRAY_TYPE_OES"
	_GLenum_map[35211] = "GL_POINT_SIZE_ARRAY_STRIDE_OES"
	_GLenum_map[35212] = "GL_POINT_SIZE_ARRAY_POINTER_OES"
	_GLenum_map[35213] = "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES"
	_GLenum_map[35214] = "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES"
	_GLenum_map[35215] = "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES"
	_GLenum_map[35328] = "GL_VERTEX_ATTRIB_MAP1_APPLE"
	_GLenum_map[35329] = "GL_VERTEX_ATTRIB_MAP2_APPLE"
	_GLenum_map[35330] = "GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE"
	_GLenum_map[35331] = "GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE"
	_GLenum_map[35332] = "GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE"
	_GLenum_map[35333] = "GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE"
	_GLenum_map[35334] = "GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE"
	_GLenum_map[35335] = "GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE"
	_GLenum_map[35336] = "GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE"
	_GLenum_map[35337] = "GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE"
	_GLenum_map[35338] = "GL_DRAW_PIXELS_APPLE"
	_GLenum_map[35339] = "GL_FENCE_APPLE"
	_GLenum_map[35340] = "GL_ELEMENT_ARRAY_APPLE"
	_GLenum_map[35341] = "GL_ELEMENT_ARRAY_TYPE_APPLE"
	_GLenum_map[35342] = "GL_ELEMENT_ARRAY_POINTER_APPLE"
	_GLenum_map[35343] = "GL_COLOR_FLOAT_APPLE"
	_GLenum_map[35345] = "GL_UNIFORM_BUFFER"
	_GLenum_map[35346] = "GL_BUFFER_SERIALIZED_MODIFY_APPLE"
	_GLenum_map[35347] = "GL_BUFFER_FLUSHING_UNMAP_APPLE"
	_GLenum_map[35348] = "GL_AUX_DEPTH_STENCIL_APPLE"
	_GLenum_map[35349] = "GL_PACK_ROW_BYTES_APPLE"
	_GLenum_map[35350] = "GL_UNPACK_ROW_BYTES_APPLE"
	_GLenum_map[35353] = "GL_RELEASED_APPLE"
	_GLenum_map[35354] = "GL_VOLATILE_APPLE"
	_GLenum_map[35355] = "GL_RETAINED_APPLE"
	_GLenum_map[35356] = "GL_UNDEFINED_APPLE"
	_GLenum_map[35357] = "GL_PURGEABLE_APPLE"
	_GLenum_map[35359] = "GL_RGB_422_APPLE"
	_GLenum_map[35368] = "GL_UNIFORM_BUFFER_BINDING"
	_GLenum_map[35369] = "GL_UNIFORM_BUFFER_START"
	_GLenum_map[35370] = "GL_UNIFORM_BUFFER_SIZE"
	_GLenum_map[35371] = "GL_MAX_VERTEX_UNIFORM_BLOCKS"
	_GLenum_map[35372] = "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT"
	_GLenum_map[35372] = "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES"
	_GLenum_map[35372] = "GL_MAX_GEOMETRY_UNIFORM_BLOCKS"
	_GLenum_map[35373] = "GL_MAX_FRAGMENT_UNIFORM_BLOCKS"
	_GLenum_map[35374] = "GL_MAX_COMBINED_UNIFORM_BLOCKS"
	_GLenum_map[35375] = "GL_MAX_UNIFORM_BUFFER_BINDINGS"
	_GLenum_map[35376] = "GL_MAX_UNIFORM_BLOCK_SIZE"
	_GLenum_map[35377] = "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"
	_GLenum_map[35378] = "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS"
	_GLenum_map[35378] = "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES"
	_GLenum_map[35378] = "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[35379] = "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"
	_GLenum_map[35380] = "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT"
	_GLenum_map[35381] = "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"
	_GLenum_map[35382] = "GL_ACTIVE_UNIFORM_BLOCKS"
	_GLenum_map[35383] = "GL_UNIFORM_TYPE"
	_GLenum_map[35384] = "GL_UNIFORM_SIZE"
	_GLenum_map[35385] = "GL_UNIFORM_NAME_LENGTH"
	_GLenum_map[35386] = "GL_UNIFORM_BLOCK_INDEX"
	_GLenum_map[35387] = "GL_UNIFORM_OFFSET"
	_GLenum_map[35388] = "GL_UNIFORM_ARRAY_STRIDE"
	_GLenum_map[35389] = "GL_UNIFORM_MATRIX_STRIDE"
	_GLenum_map[35390] = "GL_UNIFORM_IS_ROW_MAJOR"
	_GLenum_map[35391] = "GL_UNIFORM_BLOCK_BINDING"
	_GLenum_map[35392] = "GL_UNIFORM_BLOCK_DATA_SIZE"
	_GLenum_map[35393] = "GL_UNIFORM_BLOCK_NAME_LENGTH"
	_GLenum_map[35394] = "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS"
	_GLenum_map[35395] = "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"
	_GLenum_map[35396] = "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"
	_GLenum_map[35397] = "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER"
	_GLenum_map[35398] = "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"
	_GLenum_map[35400] = "GL_TEXTURE_SRGB_DECODE_EXT"
	_GLenum_map[35401] = "GL_DECODE_EXT"
	_GLenum_map[35402] = "GL_SKIP_DECODE_EXT"
	_GLenum_map[35407] = "GL_PROGRAM_PIPELINE_OBJECT_EXT"
	_GLenum_map[35409] = "GL_RGB_RAW_422_APPLE"
	_GLenum_map[35410] = "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT"
	_GLenum_map[35411] = "GL_SYNC_OBJECT_APPLE"
	_GLenum_map[35412] = "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT"
	_GLenum_map[35413] = "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT"
	_GLenum_map[35414] = "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT"
	_GLenum_map[35415] = "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT"
	_GLenum_map[35632] = "GL_FRAGMENT_SHADER_ARB"
	_GLenum_map[35632] = "GL_FRAGMENT_SHADER"
	_GLenum_map[35633] = "GL_VERTEX_SHADER"
	_GLenum_map[35633] = "GL_VERTEX_SHADER_ARB"
	_GLenum_map[35648] = "GL_PROGRAM_OBJECT_EXT"
	_GLenum_map[35648] = "GL_PROGRAM_OBJECT_ARB"
	_GLenum_map[35656] = "GL_SHADER_OBJECT_ARB"
	_GLenum_map[35656] = "GL_SHADER_OBJECT_EXT"
	_GLenum_map[35657] = "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB"
	_GLenum_map[35657] = "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS"
	_GLenum_map[35658] = "GL_MAX_VERTEX_UNIFORM_COMPONENTS"
	_GLenum_map[35658] = "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB"
	_GLenum_map[35659] = "GL_MAX_VARYING_FLOATS_ARB"
	_GLenum_map[35659] = "GL_MAX_VARYING_COMPONENTS_EXT"
	_GLenum_map[35659] = "GL_MAX_VARYING_FLOATS"
	_GLenum_map[35659] = "GL_MAX_VARYING_COMPONENTS"
	_GLenum_map[35660] = "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB"
	_GLenum_map[35660] = "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"
	_GLenum_map[35661] = "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"
	_GLenum_map[35661] = "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB"
	_GLenum_map[35662] = "GL_OBJECT_TYPE_ARB"
	_GLenum_map[35663] = "GL_OBJECT_SUBTYPE_ARB"
	_GLenum_map[35663] = "GL_SHADER_TYPE"
	_GLenum_map[35664] = "GL_FLOAT_VEC2_ARB"
	_GLenum_map[35664] = "GL_FLOAT_VEC2"
	_GLenum_map[35665] = "GL_FLOAT_VEC3_ARB"
	_GLenum_map[35665] = "GL_FLOAT_VEC3"
	_GLenum_map[35666] = "GL_FLOAT_VEC4_ARB"
	_GLenum_map[35666] = "GL_FLOAT_VEC4"
	_GLenum_map[35667] = "GL_INT_VEC2"
	_GLenum_map[35667] = "GL_INT_VEC2_ARB"
	_GLenum_map[35668] = "GL_INT_VEC3_ARB"
	_GLenum_map[35668] = "GL_INT_VEC3"
	_GLenum_map[35669] = "GL_INT_VEC4"
	_GLenum_map[35669] = "GL_INT_VEC4_ARB"
	_GLenum_map[35670] = "GL_BOOL_ARB"
	_GLenum_map[35670] = "GL_BOOL"
	_GLenum_map[35671] = "GL_BOOL_VEC2"
	_GLenum_map[35671] = "GL_BOOL_VEC2_ARB"
	_GLenum_map[35672] = "GL_BOOL_VEC3_ARB"
	_GLenum_map[35672] = "GL_BOOL_VEC3"
	_GLenum_map[35673] = "GL_BOOL_VEC4"
	_GLenum_map[35673] = "GL_BOOL_VEC4_ARB"
	_GLenum_map[35674] = "GL_FLOAT_MAT2_ARB"
	_GLenum_map[35674] = "GL_FLOAT_MAT2"
	_GLenum_map[35675] = "GL_FLOAT_MAT3_ARB"
	_GLenum_map[35675] = "GL_FLOAT_MAT3"
	_GLenum_map[35676] = "GL_FLOAT_MAT4"
	_GLenum_map[35676] = "GL_FLOAT_MAT4_ARB"
	_GLenum_map[35677] = "GL_SAMPLER_1D"
	_GLenum_map[35677] = "GL_SAMPLER_1D_ARB"
	_GLenum_map[35678] = "GL_SAMPLER_2D"
	_GLenum_map[35678] = "GL_SAMPLER_2D_ARB"
	_GLenum_map[35679] = "GL_SAMPLER_3D_ARB"
	_GLenum_map[35679] = "GL_SAMPLER_3D"
	_GLenum_map[35679] = "GL_SAMPLER_3D_OES"
	_GLenum_map[35680] = "GL_SAMPLER_CUBE_ARB"
	_GLenum_map[35680] = "GL_SAMPLER_CUBE"
	_GLenum_map[35681] = "GL_SAMPLER_1D_SHADOW_ARB"
	_GLenum_map[35681] = "GL_SAMPLER_1D_SHADOW"
	_GLenum_map[35682] = "GL_SAMPLER_2D_SHADOW_EXT"
	_GLenum_map[35682] = "GL_SAMPLER_2D_SHADOW_ARB"
	_GLenum_map[35682] = "GL_SAMPLER_2D_SHADOW"
	_GLenum_map[35683] = "GL_SAMPLER_2D_RECT_ARB"
	_GLenum_map[35683] = "GL_SAMPLER_2D_RECT"
	_GLenum_map[35684] = "GL_SAMPLER_2D_RECT_SHADOW"
	_GLenum_map[35684] = "GL_SAMPLER_2D_RECT_SHADOW_ARB"
	_GLenum_map[35685] = "GL_FLOAT_MAT2x3"
	_GLenum_map[35685] = "GL_FLOAT_MAT2x3_NV"
	_GLenum_map[35686] = "GL_FLOAT_MAT2x4_NV"
	_GLenum_map[35686] = "GL_FLOAT_MAT2x4"
	_GLenum_map[35687] = "GL_FLOAT_MAT3x2"
	_GLenum_map[35687] = "GL_FLOAT_MAT3x2_NV"
	_GLenum_map[35688] = "GL_FLOAT_MAT3x4"
	_GLenum_map[35688] = "GL_FLOAT_MAT3x4_NV"
	_GLenum_map[35689] = "GL_FLOAT_MAT4x2"
	_GLenum_map[35689] = "GL_FLOAT_MAT4x2_NV"
	_GLenum_map[35690] = "GL_FLOAT_MAT4x3"
	_GLenum_map[35690] = "GL_FLOAT_MAT4x3_NV"
	_GLenum_map[35712] = "GL_DELETE_STATUS"
	_GLenum_map[35712] = "GL_OBJECT_DELETE_STATUS_ARB"
	_GLenum_map[35713] = "GL_OBJECT_COMPILE_STATUS_ARB"
	_GLenum_map[35713] = "GL_COMPILE_STATUS"
	_GLenum_map[35714] = "GL_OBJECT_LINK_STATUS_ARB"
	_GLenum_map[35714] = "GL_LINK_STATUS"
	_GLenum_map[35715] = "GL_OBJECT_VALIDATE_STATUS_ARB"
	_GLenum_map[35715] = "GL_VALIDATE_STATUS"
	_GLenum_map[35716] = "GL_INFO_LOG_LENGTH"
	_GLenum_map[35716] = "GL_OBJECT_INFO_LOG_LENGTH_ARB"
	_GLenum_map[35717] = "GL_OBJECT_ATTACHED_OBJECTS_ARB"
	_GLenum_map[35717] = "GL_ATTACHED_SHADERS"
	_GLenum_map[35718] = "GL_ACTIVE_UNIFORMS"
	_GLenum_map[35718] = "GL_OBJECT_ACTIVE_UNIFORMS_ARB"
	_GLenum_map[35719] = "GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB"
	_GLenum_map[35719] = "GL_ACTIVE_UNIFORM_MAX_LENGTH"
	_GLenum_map[35720] = "GL_SHADER_SOURCE_LENGTH"
	_GLenum_map[35720] = "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB"
	_GLenum_map[35721] = "GL_ACTIVE_ATTRIBUTES"
	_GLenum_map[35721] = "GL_OBJECT_ACTIVE_ATTRIBUTES_ARB"
	_GLenum_map[35722] = "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"
	_GLenum_map[35722] = "GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB"
	_GLenum_map[35723] = "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES"
	_GLenum_map[35723] = "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"
	_GLenum_map[35723] = "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB"
	_GLenum_map[35724] = "GL_SHADING_LANGUAGE_VERSION"
	_GLenum_map[35724] = "GL_SHADING_LANGUAGE_VERSION_ARB"
	_GLenum_map[35725] = "GL_CURRENT_PROGRAM"
	_GLenum_map[35728] = "GL_PALETTE4_RGB8_OES"
	_GLenum_map[35729] = "GL_PALETTE4_RGBA8_OES"
	_GLenum_map[35730] = "GL_PALETTE4_R5_G6_B5_OES"
	_GLenum_map[35731] = "GL_PALETTE4_RGBA4_OES"
	_GLenum_map[35732] = "GL_PALETTE4_RGB5_A1_OES"
	_GLenum_map[35733] = "GL_PALETTE8_RGB8_OES"
	_GLenum_map[35734] = "GL_PALETTE8_RGBA8_OES"
	_GLenum_map[35735] = "GL_PALETTE8_R5_G6_B5_OES"
	_GLenum_map[35736] = "GL_PALETTE8_RGBA4_OES"
	_GLenum_map[35737] = "GL_PALETTE8_RGB5_A1_OES"
	_GLenum_map[35738] = "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES"
	_GLenum_map[35738] = "GL_IMPLEMENTATION_COLOR_READ_TYPE"
	_GLenum_map[35739] = "GL_IMPLEMENTATION_COLOR_READ_FORMAT"
	_GLenum_map[35739] = "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES"
	_GLenum_map[35740] = "GL_POINT_SIZE_ARRAY_OES"
	_GLenum_map[35741] = "GL_TEXTURE_CROP_RECT_OES"
	_GLenum_map[35742] = "GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES"
	_GLenum_map[35743] = "GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES"
	_GLenum_map[35760] = "GL_FRAGMENT_PROGRAM_POSITION_MESA"
	_GLenum_map[35761] = "GL_FRAGMENT_PROGRAM_CALLBACK_MESA"
	_GLenum_map[35762] = "GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA"
	_GLenum_map[35763] = "GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA"
	_GLenum_map[35764] = "GL_VERTEX_PROGRAM_POSITION_MESA"
	_GLenum_map[35765] = "GL_VERTEX_PROGRAM_CALLBACK_MESA"
	_GLenum_map[35766] = "GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA"
	_GLenum_map[35767] = "GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA"
	_GLenum_map[35776] = "GL_COUNTER_TYPE_AMD"
	_GLenum_map[35777] = "GL_COUNTER_RANGE_AMD"
	_GLenum_map[35778] = "GL_UNSIGNED_INT64_AMD"
	_GLenum_map[35779] = "GL_PERCENTAGE_AMD"
	_GLenum_map[35780] = "GL_PERFMON_RESULT_AVAILABLE_AMD"
	_GLenum_map[35781] = "GL_PERFMON_RESULT_SIZE_AMD"
	_GLenum_map[35782] = "GL_PERFMON_RESULT_AMD"
	_GLenum_map[35794] = "GL_TEXTURE_WIDTH_QCOM"
	_GLenum_map[35795] = "GL_TEXTURE_HEIGHT_QCOM"
	_GLenum_map[35796] = "GL_TEXTURE_DEPTH_QCOM"
	_GLenum_map[35797] = "GL_TEXTURE_INTERNAL_FORMAT_QCOM"
	_GLenum_map[35798] = "GL_TEXTURE_FORMAT_QCOM"
	_GLenum_map[35799] = "GL_TEXTURE_TYPE_QCOM"
	_GLenum_map[35800] = "GL_TEXTURE_IMAGE_VALID_QCOM"
	_GLenum_map[35801] = "GL_TEXTURE_NUM_LEVELS_QCOM"
	_GLenum_map[35802] = "GL_TEXTURE_TARGET_QCOM"
	_GLenum_map[35803] = "GL_TEXTURE_OBJECT_VALID_QCOM"
	_GLenum_map[35804] = "GL_STATE_RESTORE"
	_GLenum_map[35815] = "GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT"
	_GLenum_map[35840] = "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"
	_GLenum_map[35841] = "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"
	_GLenum_map[35842] = "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"
	_GLenum_map[35843] = "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"
	_GLenum_map[35844] = "GL_MODULATE_COLOR_IMG"
	_GLenum_map[35845] = "GL_RECIP_ADD_SIGNED_ALPHA_IMG"
	_GLenum_map[35846] = "GL_TEXTURE_ALPHA_MODULATE_IMG"
	_GLenum_map[35847] = "GL_FACTOR_ALPHA_MODULATE_IMG"
	_GLenum_map[35848] = "GL_FRAGMENT_ALPHA_MODULATE_IMG"
	_GLenum_map[35849] = "GL_ADD_BLEND_IMG"
	_GLenum_map[35850] = "GL_SGX_BINARY_IMG"
	_GLenum_map[35856] = "GL_TEXTURE_RED_TYPE"
	_GLenum_map[35856] = "GL_TEXTURE_RED_TYPE_ARB"
	_GLenum_map[35857] = "GL_TEXTURE_GREEN_TYPE_ARB"
	_GLenum_map[35857] = "GL_TEXTURE_GREEN_TYPE"
	_GLenum_map[35858] = "GL_TEXTURE_BLUE_TYPE_ARB"
	_GLenum_map[35858] = "GL_TEXTURE_BLUE_TYPE"
	_GLenum_map[35859] = "GL_TEXTURE_ALPHA_TYPE_ARB"
	_GLenum_map[35859] = "GL_TEXTURE_ALPHA_TYPE"
	_GLenum_map[35860] = "GL_TEXTURE_LUMINANCE_TYPE_ARB"
	_GLenum_map[35860] = "GL_TEXTURE_LUMINANCE_TYPE"
	_GLenum_map[35861] = "GL_TEXTURE_INTENSITY_TYPE_ARB"
	_GLenum_map[35861] = "GL_TEXTURE_INTENSITY_TYPE"
	_GLenum_map[35862] = "GL_TEXTURE_DEPTH_TYPE_ARB"
	_GLenum_map[35862] = "GL_TEXTURE_DEPTH_TYPE"
	_GLenum_map[35863] = "GL_UNSIGNED_NORMALIZED_EXT"
	_GLenum_map[35863] = "GL_UNSIGNED_NORMALIZED_ARB"
	_GLenum_map[35863] = "GL_UNSIGNED_NORMALIZED"
	_GLenum_map[35864] = "GL_TEXTURE_1D_ARRAY_EXT"
	_GLenum_map[35864] = "GL_TEXTURE_1D_ARRAY"
	_GLenum_map[35865] = "GL_PROXY_TEXTURE_1D_ARRAY_EXT"
	_GLenum_map[35865] = "GL_PROXY_TEXTURE_1D_ARRAY"
	_GLenum_map[35866] = "GL_TEXTURE_2D_ARRAY"
	_GLenum_map[35866] = "GL_TEXTURE_2D_ARRAY_EXT"
	_GLenum_map[35867] = "GL_PROXY_TEXTURE_2D_ARRAY_EXT"
	_GLenum_map[35867] = "GL_PROXY_TEXTURE_2D_ARRAY"
	_GLenum_map[35868] = "GL_TEXTURE_BINDING_1D_ARRAY"
	_GLenum_map[35868] = "GL_TEXTURE_BINDING_1D_ARRAY_EXT"
	_GLenum_map[35869] = "GL_TEXTURE_BINDING_2D_ARRAY"
	_GLenum_map[35869] = "GL_TEXTURE_BINDING_2D_ARRAY_EXT"
	_GLenum_map[35878] = "GL_GEOMETRY_PROGRAM_NV"
	_GLenum_map[35879] = "GL_MAX_PROGRAM_OUTPUT_VERTICES_NV"
	_GLenum_map[35880] = "GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV"
	_GLenum_map[35881] = "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS"
	_GLenum_map[35881] = "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB"
	_GLenum_map[35881] = "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES"
	_GLenum_map[35881] = "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_BINDING_OES"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_OES"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_BINDING"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_ARB"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_EXT"
	_GLenum_map[35882] = "GL_TEXTURE_BUFFER_BINDING_EXT"
	_GLenum_map[35883] = "GL_MAX_TEXTURE_BUFFER_SIZE_ARB"
	_GLenum_map[35883] = "GL_MAX_TEXTURE_BUFFER_SIZE_EXT"
	_GLenum_map[35883] = "GL_MAX_TEXTURE_BUFFER_SIZE_OES"
	_GLenum_map[35883] = "GL_MAX_TEXTURE_BUFFER_SIZE"
	_GLenum_map[35884] = "GL_TEXTURE_BINDING_BUFFER_OES"
	_GLenum_map[35884] = "GL_TEXTURE_BINDING_BUFFER"
	_GLenum_map[35884] = "GL_TEXTURE_BINDING_BUFFER_ARB"
	_GLenum_map[35884] = "GL_TEXTURE_BINDING_BUFFER_EXT"
	_GLenum_map[35885] = "GL_TEXTURE_BUFFER_DATA_STORE_BINDING"
	_GLenum_map[35885] = "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT"
	_GLenum_map[35885] = "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES"
	_GLenum_map[35885] = "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB"
	_GLenum_map[35886] = "GL_TEXTURE_BUFFER_FORMAT_EXT"
	_GLenum_map[35886] = "GL_TEXTURE_BUFFER_FORMAT_ARB"
	_GLenum_map[35887] = "GL_ANY_SAMPLES_PASSED_EXT"
	_GLenum_map[35887] = "GL_ANY_SAMPLES_PASSED"
	_GLenum_map[35894] = "GL_SAMPLE_SHADING_OES"
	_GLenum_map[35894] = "GL_SAMPLE_SHADING_ARB"
	_GLenum_map[35894] = "GL_SAMPLE_SHADING"
	_GLenum_map[35895] = "GL_MIN_SAMPLE_SHADING_VALUE"
	_GLenum_map[35895] = "GL_MIN_SAMPLE_SHADING_VALUE_ARB"
	_GLenum_map[35895] = "GL_MIN_SAMPLE_SHADING_VALUE_OES"
	_GLenum_map[35898] = "GL_R11F_G11F_B10F_APPLE"
	_GLenum_map[35898] = "GL_R11F_G11F_B10F"
	_GLenum_map[35898] = "GL_R11F_G11F_B10F_EXT"
	_GLenum_map[35899] = "GL_UNSIGNED_INT_10F_11F_11F_REV_EXT"
	_GLenum_map[35899] = "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE"
	_GLenum_map[35899] = "GL_UNSIGNED_INT_10F_11F_11F_REV"
	_GLenum_map[35900] = "GL_RGBA_SIGNED_COMPONENTS_EXT"
	_GLenum_map[35901] = "GL_RGB9_E5_APPLE"
	_GLenum_map[35901] = "GL_RGB9_E5"
	_GLenum_map[35901] = "GL_RGB9_E5_EXT"
	_GLenum_map[35902] = "GL_UNSIGNED_INT_5_9_9_9_REV_EXT"
	_GLenum_map[35902] = "GL_UNSIGNED_INT_5_9_9_9_REV"
	_GLenum_map[35902] = "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE"
	_GLenum_map[35903] = "GL_TEXTURE_SHARED_SIZE"
	_GLenum_map[35903] = "GL_TEXTURE_SHARED_SIZE_EXT"
	_GLenum_map[35904] = "GL_SRGB_EXT"
	_GLenum_map[35904] = "GL_SRGB"
	_GLenum_map[35905] = "GL_SRGB8_NV"
	_GLenum_map[35905] = "GL_SRGB8"
	_GLenum_map[35905] = "GL_SRGB8_EXT"
	_GLenum_map[35906] = "GL_SRGB_ALPHA_EXT"
	_GLenum_map[35906] = "GL_SRGB_ALPHA"
	_GLenum_map[35907] = "GL_SRGB8_ALPHA8_EXT"
	_GLenum_map[35907] = "GL_SRGB8_ALPHA8"
	_GLenum_map[35908] = "GL_SLUMINANCE_ALPHA"
	_GLenum_map[35908] = "GL_SLUMINANCE_ALPHA_NV"
	_GLenum_map[35908] = "GL_SLUMINANCE_ALPHA_EXT"
	_GLenum_map[35909] = "GL_SLUMINANCE8_ALPHA8"
	_GLenum_map[35909] = "GL_SLUMINANCE8_ALPHA8_EXT"
	_GLenum_map[35909] = "GL_SLUMINANCE8_ALPHA8_NV"
	_GLenum_map[35910] = "GL_SLUMINANCE_NV"
	_GLenum_map[35910] = "GL_SLUMINANCE_EXT"
	_GLenum_map[35910] = "GL_SLUMINANCE"
	_GLenum_map[35911] = "GL_SLUMINANCE8_EXT"
	_GLenum_map[35911] = "GL_SLUMINANCE8_NV"
	_GLenum_map[35911] = "GL_SLUMINANCE8"
	_GLenum_map[35912] = "GL_COMPRESSED_SRGB_EXT"
	_GLenum_map[35912] = "GL_COMPRESSED_SRGB"
	_GLenum_map[35913] = "GL_COMPRESSED_SRGB_ALPHA_EXT"
	_GLenum_map[35913] = "GL_COMPRESSED_SRGB_ALPHA"
	_GLenum_map[35914] = "GL_COMPRESSED_SLUMINANCE"
	_GLenum_map[35914] = "GL_COMPRESSED_SLUMINANCE_EXT"
	_GLenum_map[35915] = "GL_COMPRESSED_SLUMINANCE_ALPHA_EXT"
	_GLenum_map[35915] = "GL_COMPRESSED_SLUMINANCE_ALPHA"
	_GLenum_map[35916] = "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT"
	_GLenum_map[35916] = "GL_COMPRESSED_SRGB_S3TC_DXT1_NV"
	_GLenum_map[35917] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV"
	_GLenum_map[35917] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"
	_GLenum_map[35918] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"
	_GLenum_map[35918] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV"
	_GLenum_map[35919] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV"
	_GLenum_map[35919] = "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"
	_GLenum_map[35952] = "GL_COMPRESSED_LUMINANCE_LATC1_EXT"
	_GLenum_map[35953] = "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT"
	_GLenum_map[35954] = "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT"
	_GLenum_map[35955] = "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT"
	_GLenum_map[35956] = "GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[35957] = "GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[35958] = "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"
	_GLenum_map[35958] = "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT"
	_GLenum_map[35959] = "GL_BACK_PRIMARY_COLOR_NV"
	_GLenum_map[35960] = "GL_BACK_SECONDARY_COLOR_NV"
	_GLenum_map[35961] = "GL_TEXTURE_COORD_NV"
	_GLenum_map[35962] = "GL_CLIP_DISTANCE_NV"
	_GLenum_map[35963] = "GL_VERTEX_ID_NV"
	_GLenum_map[35964] = "GL_PRIMITIVE_ID_NV"
	_GLenum_map[35965] = "GL_GENERIC_ATTRIB_NV"
	_GLenum_map[35966] = "GL_TRANSFORM_FEEDBACK_ATTRIBS_NV"
	_GLenum_map[35967] = "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT"
	_GLenum_map[35967] = "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV"
	_GLenum_map[35967] = "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"
	_GLenum_map[35968] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT"
	_GLenum_map[35968] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"
	_GLenum_map[35968] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV"
	_GLenum_map[35969] = "GL_ACTIVE_VARYINGS_NV"
	_GLenum_map[35970] = "GL_ACTIVE_VARYING_MAX_LENGTH_NV"
	_GLenum_map[35971] = "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT"
	_GLenum_map[35971] = "GL_TRANSFORM_FEEDBACK_VARYINGS"
	_GLenum_map[35971] = "GL_TRANSFORM_FEEDBACK_VARYINGS_NV"
	_GLenum_map[35972] = "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT"
	_GLenum_map[35972] = "GL_TRANSFORM_FEEDBACK_BUFFER_START"
	_GLenum_map[35972] = "GL_TRANSFORM_FEEDBACK_BUFFER_START_NV"
	_GLenum_map[35973] = "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"
	_GLenum_map[35973] = "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT"
	_GLenum_map[35973] = "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV"
	_GLenum_map[35974] = "GL_TRANSFORM_FEEDBACK_RECORD_NV"
	_GLenum_map[35975] = "GL_PRIMITIVES_GENERATED"
	_GLenum_map[35975] = "GL_PRIMITIVES_GENERATED_EXT"
	_GLenum_map[35975] = "GL_PRIMITIVES_GENERATED_NV"
	_GLenum_map[35975] = "GL_PRIMITIVES_GENERATED_OES"
	_GLenum_map[35976] = "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT"
	_GLenum_map[35976] = "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"
	_GLenum_map[35976] = "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV"
	_GLenum_map[35977] = "GL_RASTERIZER_DISCARD_NV"
	_GLenum_map[35977] = "GL_RASTERIZER_DISCARD"
	_GLenum_map[35977] = "GL_RASTERIZER_DISCARD_EXT"
	_GLenum_map[35978] = "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT"
	_GLenum_map[35978] = "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"
	_GLenum_map[35978] = "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV"
	_GLenum_map[35979] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT"
	_GLenum_map[35979] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"
	_GLenum_map[35979] = "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV"
	_GLenum_map[35980] = "GL_INTERLEAVED_ATTRIBS_EXT"
	_GLenum_map[35980] = "GL_INTERLEAVED_ATTRIBS"
	_GLenum_map[35980] = "GL_INTERLEAVED_ATTRIBS_NV"
	_GLenum_map[35981] = "GL_SEPARATE_ATTRIBS_NV"
	_GLenum_map[35981] = "GL_SEPARATE_ATTRIBS"
	_GLenum_map[35981] = "GL_SEPARATE_ATTRIBS_EXT"
	_GLenum_map[35982] = "GL_TRANSFORM_FEEDBACK_BUFFER"
	_GLenum_map[35982] = "GL_TRANSFORM_FEEDBACK_BUFFER_NV"
	_GLenum_map[35982] = "GL_TRANSFORM_FEEDBACK_BUFFER_EXT"
	_GLenum_map[35983] = "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"
	_GLenum_map[35983] = "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV"
	_GLenum_map[35983] = "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT"
	_GLenum_map[35986] = "GL_ATC_RGB_AMD"
	_GLenum_map[35987] = "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD"
	_GLenum_map[36000] = "GL_POINT_SPRITE_COORD_ORIGIN"
	_GLenum_map[36001] = "GL_LOWER_LEFT"
	_GLenum_map[36002] = "GL_UPPER_LEFT"
	_GLenum_map[36003] = "GL_STENCIL_BACK_REF"
	_GLenum_map[36004] = "GL_STENCIL_BACK_VALUE_MASK"
	_GLenum_map[36005] = "GL_STENCIL_BACK_WRITEMASK"
	_GLenum_map[36006] = "GL_FRAMEBUFFER_BINDING"
	_GLenum_map[36006] = "GL_FRAMEBUFFER_BINDING_EXT"
	_GLenum_map[36006] = "GL_FRAMEBUFFER_BINDING_ANGLE"
	_GLenum_map[36006] = "GL_DRAW_FRAMEBUFFER_BINDING_APPLE"
	_GLenum_map[36006] = "GL_DRAW_FRAMEBUFFER_BINDING_ANGLE"
	_GLenum_map[36006] = "GL_DRAW_FRAMEBUFFER_BINDING"
	_GLenum_map[36006] = "GL_DRAW_FRAMEBUFFER_BINDING_EXT"
	_GLenum_map[36006] = "GL_DRAW_FRAMEBUFFER_BINDING_NV"
	_GLenum_map[36006] = "GL_FRAMEBUFFER_BINDING_OES"
	_GLenum_map[36007] = "GL_RENDERBUFFER_BINDING"
	_GLenum_map[36007] = "GL_RENDERBUFFER_BINDING_ANGLE"
	_GLenum_map[36007] = "GL_RENDERBUFFER_BINDING_EXT"
	_GLenum_map[36007] = "GL_RENDERBUFFER_BINDING_OES"
	_GLenum_map[36008] = "GL_READ_FRAMEBUFFER"
	_GLenum_map[36008] = "GL_READ_FRAMEBUFFER_ANGLE"
	_GLenum_map[36008] = "GL_READ_FRAMEBUFFER_NV"
	_GLenum_map[36008] = "GL_READ_FRAMEBUFFER_APPLE"
	_GLenum_map[36008] = "GL_READ_FRAMEBUFFER_EXT"
	_GLenum_map[36009] = "GL_DRAW_FRAMEBUFFER"
	_GLenum_map[36009] = "GL_DRAW_FRAMEBUFFER_APPLE"
	_GLenum_map[36009] = "GL_DRAW_FRAMEBUFFER_ANGLE"
	_GLenum_map[36009] = "GL_DRAW_FRAMEBUFFER_EXT"
	_GLenum_map[36009] = "GL_DRAW_FRAMEBUFFER_NV"
	_GLenum_map[36010] = "GL_READ_FRAMEBUFFER_BINDING"
	_GLenum_map[36010] = "GL_READ_FRAMEBUFFER_BINDING_NV"
	_GLenum_map[36010] = "GL_READ_FRAMEBUFFER_BINDING_EXT"
	_GLenum_map[36010] = "GL_READ_FRAMEBUFFER_BINDING_ANGLE"
	_GLenum_map[36010] = "GL_READ_FRAMEBUFFER_BINDING_APPLE"
	_GLenum_map[36011] = "GL_RENDERBUFFER_COVERAGE_SAMPLES_NV"
	_GLenum_map[36011] = "GL_RENDERBUFFER_SAMPLES_APPLE"
	_GLenum_map[36011] = "GL_RENDERBUFFER_SAMPLES_EXT"
	_GLenum_map[36011] = "GL_RENDERBUFFER_SAMPLES"
	_GLenum_map[36011] = "GL_RENDERBUFFER_SAMPLES_NV"
	_GLenum_map[36011] = "GL_RENDERBUFFER_SAMPLES_ANGLE"
	_GLenum_map[36012] = "GL_DEPTH_COMPONENT32F"
	_GLenum_map[36013] = "GL_DEPTH32F_STENCIL8"
	_GLenum_map[36048] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT"
	_GLenum_map[36048] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES"
	_GLenum_map[36048] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"
	_GLenum_map[36049] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"
	_GLenum_map[36049] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT"
	_GLenum_map[36049] = "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES"
	_GLenum_map[36050] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT"
	_GLenum_map[36050] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES"
	_GLenum_map[36050] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"
	_GLenum_map[36051] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
	_GLenum_map[36051] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT"
	_GLenum_map[36051] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES"
	_GLenum_map[36052] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT"
	_GLenum_map[36052] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"
	_GLenum_map[36052] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT"
	_GLenum_map[36052] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES"
	_GLenum_map[36053] = "GL_FRAMEBUFFER_COMPLETE"
	_GLenum_map[36053] = "GL_FRAMEBUFFER_COMPLETE_OES"
	_GLenum_map[36053] = "GL_FRAMEBUFFER_COMPLETE_EXT"
	_GLenum_map[36054] = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES"
	_GLenum_map[36054] = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT"
	_GLenum_map[36054] = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"
	_GLenum_map[36055] = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT"
	_GLenum_map[36055] = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES"
	_GLenum_map[36055] = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"
	_GLenum_map[36057] = "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT"
	_GLenum_map[36057] = "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES"
	_GLenum_map[36057] = "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS"
	_GLenum_map[36058] = "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES"
	_GLenum_map[36058] = "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT"
	_GLenum_map[36059] = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"
	_GLenum_map[36059] = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT"
	_GLenum_map[36059] = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES"
	_GLenum_map[36060] = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"
	_GLenum_map[36060] = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES"
	_GLenum_map[36060] = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT"
	_GLenum_map[36061] = "GL_FRAMEBUFFER_UNSUPPORTED_EXT"
	_GLenum_map[36061] = "GL_FRAMEBUFFER_UNSUPPORTED"
	_GLenum_map[36061] = "GL_FRAMEBUFFER_UNSUPPORTED_OES"
	_GLenum_map[36063] = "GL_MAX_COLOR_ATTACHMENTS"
	_GLenum_map[36063] = "GL_MAX_COLOR_ATTACHMENTS_NV"
	_GLenum_map[36063] = "GL_MAX_COLOR_ATTACHMENTS_EXT"
	_GLenum_map[36064] = "GL_COLOR_ATTACHMENT0_EXT"
	_GLenum_map[36064] = "GL_COLOR_ATTACHMENT0_NV"
	_GLenum_map[36064] = "GL_COLOR_ATTACHMENT0"
	_GLenum_map[36064] = "GL_COLOR_ATTACHMENT0_OES"
	_GLenum_map[36065] = "GL_COLOR_ATTACHMENT1_EXT"
	_GLenum_map[36065] = "GL_COLOR_ATTACHMENT1"
	_GLenum_map[36065] = "GL_COLOR_ATTACHMENT1_NV"
	_GLenum_map[36066] = "GL_COLOR_ATTACHMENT2"
	_GLenum_map[36066] = "GL_COLOR_ATTACHMENT2_NV"
	_GLenum_map[36066] = "GL_COLOR_ATTACHMENT2_EXT"
	_GLenum_map[36067] = "GL_COLOR_ATTACHMENT3"
	_GLenum_map[36067] = "GL_COLOR_ATTACHMENT3_EXT"
	_GLenum_map[36067] = "GL_COLOR_ATTACHMENT3_NV"
	_GLenum_map[36068] = "GL_COLOR_ATTACHMENT4_EXT"
	_GLenum_map[36068] = "GL_COLOR_ATTACHMENT4"
	_GLenum_map[36068] = "GL_COLOR_ATTACHMENT4_NV"
	_GLenum_map[36069] = "GL_COLOR_ATTACHMENT5_NV"
	_GLenum_map[36069] = "GL_COLOR_ATTACHMENT5_EXT"
	_GLenum_map[36069] = "GL_COLOR_ATTACHMENT5"
	_GLenum_map[36070] = "GL_COLOR_ATTACHMENT6"
	_GLenum_map[36070] = "GL_COLOR_ATTACHMENT6_NV"
	_GLenum_map[36070] = "GL_COLOR_ATTACHMENT6_EXT"
	_GLenum_map[36071] = "GL_COLOR_ATTACHMENT7"
	_GLenum_map[36071] = "GL_COLOR_ATTACHMENT7_NV"
	_GLenum_map[36071] = "GL_COLOR_ATTACHMENT7_EXT"
	_GLenum_map[36072] = "GL_COLOR_ATTACHMENT8_NV"
	_GLenum_map[36072] = "GL_COLOR_ATTACHMENT8_EXT"
	_GLenum_map[36072] = "GL_COLOR_ATTACHMENT8"
	_GLenum_map[36073] = "GL_COLOR_ATTACHMENT9_EXT"
	_GLenum_map[36073] = "GL_COLOR_ATTACHMENT9_NV"
	_GLenum_map[36073] = "GL_COLOR_ATTACHMENT9"
	_GLenum_map[36074] = "GL_COLOR_ATTACHMENT10_NV"
	_GLenum_map[36074] = "GL_COLOR_ATTACHMENT10"
	_GLenum_map[36074] = "GL_COLOR_ATTACHMENT10_EXT"
	_GLenum_map[36075] = "GL_COLOR_ATTACHMENT11"
	_GLenum_map[36075] = "GL_COLOR_ATTACHMENT11_NV"
	_GLenum_map[36075] = "GL_COLOR_ATTACHMENT11_EXT"
	_GLenum_map[36076] = "GL_COLOR_ATTACHMENT12_NV"
	_GLenum_map[36076] = "GL_COLOR_ATTACHMENT12"
	_GLenum_map[36076] = "GL_COLOR_ATTACHMENT12_EXT"
	_GLenum_map[36077] = "GL_COLOR_ATTACHMENT13_EXT"
	_GLenum_map[36077] = "GL_COLOR_ATTACHMENT13_NV"
	_GLenum_map[36077] = "GL_COLOR_ATTACHMENT13"
	_GLenum_map[36078] = "GL_COLOR_ATTACHMENT14_NV"
	_GLenum_map[36078] = "GL_COLOR_ATTACHMENT14_EXT"
	_GLenum_map[36078] = "GL_COLOR_ATTACHMENT14"
	_GLenum_map[36079] = "GL_COLOR_ATTACHMENT15"
	_GLenum_map[36079] = "GL_COLOR_ATTACHMENT15_EXT"
	_GLenum_map[36079] = "GL_COLOR_ATTACHMENT15_NV"
	_GLenum_map[36080] = "GL_COLOR_ATTACHMENT16"
	_GLenum_map[36081] = "GL_COLOR_ATTACHMENT17"
	_GLenum_map[36082] = "GL_COLOR_ATTACHMENT18"
	_GLenum_map[36083] = "GL_COLOR_ATTACHMENT19"
	_GLenum_map[36084] = "GL_COLOR_ATTACHMENT20"
	_GLenum_map[36085] = "GL_COLOR_ATTACHMENT21"
	_GLenum_map[36086] = "GL_COLOR_ATTACHMENT22"
	_GLenum_map[36087] = "GL_COLOR_ATTACHMENT23"
	_GLenum_map[36088] = "GL_COLOR_ATTACHMENT24"
	_GLenum_map[36089] = "GL_COLOR_ATTACHMENT25"
	_GLenum_map[36090] = "GL_COLOR_ATTACHMENT26"
	_GLenum_map[36091] = "GL_COLOR_ATTACHMENT27"
	_GLenum_map[36092] = "GL_COLOR_ATTACHMENT28"
	_GLenum_map[36093] = "GL_COLOR_ATTACHMENT29"
	_GLenum_map[36094] = "GL_COLOR_ATTACHMENT30"
	_GLenum_map[36095] = "GL_COLOR_ATTACHMENT31"
	_GLenum_map[36096] = "GL_DEPTH_ATTACHMENT"
	_GLenum_map[36096] = "GL_DEPTH_ATTACHMENT_EXT"
	_GLenum_map[36096] = "GL_DEPTH_ATTACHMENT_OES"
	_GLenum_map[36128] = "GL_STENCIL_ATTACHMENT_OES"
	_GLenum_map[36128] = "GL_STENCIL_ATTACHMENT"
	_GLenum_map[36128] = "GL_STENCIL_ATTACHMENT_EXT"
	_GLenum_map[36160] = "GL_FRAMEBUFFER_EXT"
	_GLenum_map[36160] = "GL_FRAMEBUFFER_OES"
	_GLenum_map[36160] = "GL_FRAMEBUFFER"
	_GLenum_map[36161] = "GL_RENDERBUFFER_OES"
	_GLenum_map[36161] = "GL_RENDERBUFFER_EXT"
	_GLenum_map[36161] = "GL_RENDERBUFFER"
	_GLenum_map[36162] = "GL_RENDERBUFFER_WIDTH"
	_GLenum_map[36162] = "GL_RENDERBUFFER_WIDTH_OES"
	_GLenum_map[36162] = "GL_RENDERBUFFER_WIDTH_EXT"
	_GLenum_map[36163] = "GL_RENDERBUFFER_HEIGHT_OES"
	_GLenum_map[36163] = "GL_RENDERBUFFER_HEIGHT"
	_GLenum_map[36163] = "GL_RENDERBUFFER_HEIGHT_EXT"
	_GLenum_map[36164] = "GL_RENDERBUFFER_INTERNAL_FORMAT"
	_GLenum_map[36164] = "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT"
	_GLenum_map[36164] = "GL_RENDERBUFFER_INTERNAL_FORMAT_OES"
	_GLenum_map[36166] = "GL_STENCIL_INDEX1_OES"
	_GLenum_map[36166] = "GL_STENCIL_INDEX1_EXT"
	_GLenum_map[36166] = "GL_STENCIL_INDEX1"
	_GLenum_map[36167] = "GL_STENCIL_INDEX4_EXT"
	_GLenum_map[36167] = "GL_STENCIL_INDEX4"
	_GLenum_map[36167] = "GL_STENCIL_INDEX4_OES"
	_GLenum_map[36168] = "GL_STENCIL_INDEX8_EXT"
	_GLenum_map[36168] = "GL_STENCIL_INDEX8"
	_GLenum_map[36168] = "GL_STENCIL_INDEX8_OES"
	_GLenum_map[36169] = "GL_STENCIL_INDEX16"
	_GLenum_map[36169] = "GL_STENCIL_INDEX16_EXT"
	_GLenum_map[36176] = "GL_RENDERBUFFER_RED_SIZE_EXT"
	_GLenum_map[36176] = "GL_RENDERBUFFER_RED_SIZE"
	_GLenum_map[36176] = "GL_RENDERBUFFER_RED_SIZE_OES"
	_GLenum_map[36177] = "GL_RENDERBUFFER_GREEN_SIZE_EXT"
	_GLenum_map[36177] = "GL_RENDERBUFFER_GREEN_SIZE"
	_GLenum_map[36177] = "GL_RENDERBUFFER_GREEN_SIZE_OES"
	_GLenum_map[36178] = "GL_RENDERBUFFER_BLUE_SIZE_OES"
	_GLenum_map[36178] = "GL_RENDERBUFFER_BLUE_SIZE"
	_GLenum_map[36178] = "GL_RENDERBUFFER_BLUE_SIZE_EXT"
	_GLenum_map[36179] = "GL_RENDERBUFFER_ALPHA_SIZE"
	_GLenum_map[36179] = "GL_RENDERBUFFER_ALPHA_SIZE_OES"
	_GLenum_map[36179] = "GL_RENDERBUFFER_ALPHA_SIZE_EXT"
	_GLenum_map[36180] = "GL_RENDERBUFFER_DEPTH_SIZE_OES"
	_GLenum_map[36180] = "GL_RENDERBUFFER_DEPTH_SIZE_EXT"
	_GLenum_map[36180] = "GL_RENDERBUFFER_DEPTH_SIZE"
	_GLenum_map[36181] = "GL_RENDERBUFFER_STENCIL_SIZE"
	_GLenum_map[36181] = "GL_RENDERBUFFER_STENCIL_SIZE_OES"
	_GLenum_map[36181] = "GL_RENDERBUFFER_STENCIL_SIZE_EXT"
	_GLenum_map[36182] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE"
	_GLenum_map[36182] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT"
	_GLenum_map[36182] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"
	_GLenum_map[36182] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV"
	_GLenum_map[36182] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE"
	_GLenum_map[36183] = "GL_MAX_SAMPLES_ANGLE"
	_GLenum_map[36183] = "GL_MAX_SAMPLES_APPLE"
	_GLenum_map[36183] = "GL_MAX_SAMPLES_EXT"
	_GLenum_map[36183] = "GL_MAX_SAMPLES_NV"
	_GLenum_map[36183] = "GL_MAX_SAMPLES"
	_GLenum_map[36192] = "GL_TEXTURE_GEN_STR_OES"
	_GLenum_map[36193] = "GL_HALF_FLOAT_OES"
	_GLenum_map[36194] = "GL_RGB565"
	_GLenum_map[36194] = "GL_RGB565_OES"
	_GLenum_map[36196] = "GL_ETC1_RGB8_OES"
	_GLenum_map[36197] = "GL_TEXTURE_EXTERNAL_OES"
	_GLenum_map[36198] = "GL_SAMPLER_EXTERNAL_OES"
	_GLenum_map[36199] = "GL_TEXTURE_BINDING_EXTERNAL_OES"
	_GLenum_map[36200] = "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES"
	_GLenum_map[36201] = "GL_PRIMITIVE_RESTART_FIXED_INDEX"
	_GLenum_map[36202] = "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT"
	_GLenum_map[36202] = "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"
	_GLenum_map[36203] = "GL_MAX_ELEMENT_INDEX"
	_GLenum_map[36204] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT"
	_GLenum_map[36208] = "GL_RGBA32UI_EXT"
	_GLenum_map[36208] = "GL_RGBA32UI"
	_GLenum_map[36209] = "GL_RGB32UI_EXT"
	_GLenum_map[36209] = "GL_RGB32UI"
	_GLenum_map[36210] = "GL_ALPHA32UI_EXT"
	_GLenum_map[36211] = "GL_INTENSITY32UI_EXT"
	_GLenum_map[36212] = "GL_LUMINANCE32UI_EXT"
	_GLenum_map[36213] = "GL_LUMINANCE_ALPHA32UI_EXT"
	_GLenum_map[36214] = "GL_RGBA16UI_EXT"
	_GLenum_map[36214] = "GL_RGBA16UI"
	_GLenum_map[36215] = "GL_RGB16UI"
	_GLenum_map[36215] = "GL_RGB16UI_EXT"
	_GLenum_map[36216] = "GL_ALPHA16UI_EXT"
	_GLenum_map[36217] = "GL_INTENSITY16UI_EXT"
	_GLenum_map[36218] = "GL_LUMINANCE16UI_EXT"
	_GLenum_map[36219] = "GL_LUMINANCE_ALPHA16UI_EXT"
	_GLenum_map[36220] = "GL_RGBA8UI"
	_GLenum_map[36220] = "GL_RGBA8UI_EXT"
	_GLenum_map[36221] = "GL_RGB8UI_EXT"
	_GLenum_map[36221] = "GL_RGB8UI"
	_GLenum_map[36222] = "GL_ALPHA8UI_EXT"
	_GLenum_map[36223] = "GL_INTENSITY8UI_EXT"
	_GLenum_map[36224] = "GL_LUMINANCE8UI_EXT"
	_GLenum_map[36225] = "GL_LUMINANCE_ALPHA8UI_EXT"
	_GLenum_map[36226] = "GL_RGBA32I_EXT"
	_GLenum_map[36226] = "GL_RGBA32I"
	_GLenum_map[36227] = "GL_RGB32I"
	_GLenum_map[36227] = "GL_RGB32I_EXT"
	_GLenum_map[36228] = "GL_ALPHA32I_EXT"
	_GLenum_map[36229] = "GL_INTENSITY32I_EXT"
	_GLenum_map[36230] = "GL_LUMINANCE32I_EXT"
	_GLenum_map[36231] = "GL_LUMINANCE_ALPHA32I_EXT"
	_GLenum_map[36232] = "GL_RGBA16I"
	_GLenum_map[36232] = "GL_RGBA16I_EXT"
	_GLenum_map[36233] = "GL_RGB16I"
	_GLenum_map[36233] = "GL_RGB16I_EXT"
	_GLenum_map[36234] = "GL_ALPHA16I_EXT"
	_GLenum_map[36235] = "GL_INTENSITY16I_EXT"
	_GLenum_map[36236] = "GL_LUMINANCE16I_EXT"
	_GLenum_map[36237] = "GL_LUMINANCE_ALPHA16I_EXT"
	_GLenum_map[36238] = "GL_RGBA8I"
	_GLenum_map[36238] = "GL_RGBA8I_EXT"
	_GLenum_map[36239] = "GL_RGB8I_EXT"
	_GLenum_map[36239] = "GL_RGB8I"
	_GLenum_map[36240] = "GL_ALPHA8I_EXT"
	_GLenum_map[36241] = "GL_INTENSITY8I_EXT"
	_GLenum_map[36242] = "GL_LUMINANCE8I_EXT"
	_GLenum_map[36243] = "GL_LUMINANCE_ALPHA8I_EXT"
	_GLenum_map[36244] = "GL_RED_INTEGER"
	_GLenum_map[36244] = "GL_RED_INTEGER_EXT"
	_GLenum_map[36245] = "GL_GREEN_INTEGER_EXT"
	_GLenum_map[36245] = "GL_GREEN_INTEGER"
	_GLenum_map[36246] = "GL_BLUE_INTEGER_EXT"
	_GLenum_map[36246] = "GL_BLUE_INTEGER"
	_GLenum_map[36247] = "GL_ALPHA_INTEGER_EXT"
	_GLenum_map[36247] = "GL_ALPHA_INTEGER"
	_GLenum_map[36248] = "GL_RGB_INTEGER_EXT"
	_GLenum_map[36248] = "GL_RGB_INTEGER"
	_GLenum_map[36249] = "GL_RGBA_INTEGER"
	_GLenum_map[36249] = "GL_RGBA_INTEGER_EXT"
	_GLenum_map[36250] = "GL_BGR_INTEGER_EXT"
	_GLenum_map[36250] = "GL_BGR_INTEGER"
	_GLenum_map[36251] = "GL_BGRA_INTEGER"
	_GLenum_map[36251] = "GL_BGRA_INTEGER_EXT"
	_GLenum_map[36252] = "GL_LUMINANCE_INTEGER_EXT"
	_GLenum_map[36253] = "GL_LUMINANCE_ALPHA_INTEGER_EXT"
	_GLenum_map[36254] = "GL_RGBA_INTEGER_MODE_EXT"
	_GLenum_map[36255] = "GL_INT_2_10_10_10_REV"
	_GLenum_map[36256] = "GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV"
	_GLenum_map[36257] = "GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV"
	_GLenum_map[36258] = "GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[36259] = "GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[36260] = "GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[36261] = "GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV"
	_GLenum_map[36262] = "GL_MAX_PROGRAM_GENERIC_RESULTS_NV"
	_GLenum_map[36263] = "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB"
	_GLenum_map[36263] = "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES"
	_GLenum_map[36263] = "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT"
	_GLenum_map[36263] = "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"
	_GLenum_map[36264] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB"
	_GLenum_map[36264] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES"
	_GLenum_map[36264] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT"
	_GLenum_map[36264] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"
	_GLenum_map[36265] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT"
	_GLenum_map[36265] = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB"
	_GLenum_map[36266] = "GL_LAYER_NV"
	_GLenum_map[36267] = "GL_DEPTH_COMPONENT32F_NV"
	_GLenum_map[36268] = "GL_DEPTH32F_STENCIL8_NV"
	_GLenum_map[36269] = "GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV"
	_GLenum_map[36269] = "GL_FLOAT_32_UNSIGNED_INT_24_8_REV"
	_GLenum_map[36270] = "GL_SHADER_INCLUDE_ARB"
	_GLenum_map[36271] = "GL_DEPTH_BUFFER_FLOAT_MODE_NV"
	_GLenum_map[36281] = "GL_FRAMEBUFFER_SRGB"
	_GLenum_map[36281] = "GL_FRAMEBUFFER_SRGB_EXT"
	_GLenum_map[36282] = "GL_FRAMEBUFFER_SRGB_CAPABLE_EXT"
	_GLenum_map[36283] = "GL_COMPRESSED_RED_RGTC1_EXT"
	_GLenum_map[36283] = "GL_COMPRESSED_RED_RGTC1"
	_GLenum_map[36284] = "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT"
	_GLenum_map[36284] = "GL_COMPRESSED_SIGNED_RED_RGTC1"
	_GLenum_map[36285] = "GL_COMPRESSED_RG_RGTC2"
	_GLenum_map[36285] = "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"
	_GLenum_map[36286] = "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"
	_GLenum_map[36286] = "GL_COMPRESSED_SIGNED_RG_RGTC2"
	_GLenum_map[36288] = "GL_SAMPLER_1D_ARRAY"
	_GLenum_map[36288] = "GL_SAMPLER_1D_ARRAY_EXT"
	_GLenum_map[36289] = "GL_SAMPLER_2D_ARRAY"
	_GLenum_map[36289] = "GL_SAMPLER_2D_ARRAY_EXT"
	_GLenum_map[36290] = "GL_SAMPLER_BUFFER"
	_GLenum_map[36290] = "GL_SAMPLER_BUFFER_EXT"
	_GLenum_map[36290] = "GL_SAMPLER_BUFFER_OES"
	_GLenum_map[36291] = "GL_SAMPLER_1D_ARRAY_SHADOW"
	_GLenum_map[36291] = "GL_SAMPLER_1D_ARRAY_SHADOW_EXT"
	_GLenum_map[36292] = "GL_SAMPLER_2D_ARRAY_SHADOW"
	_GLenum_map[36292] = "GL_SAMPLER_2D_ARRAY_SHADOW_NV"
	_GLenum_map[36292] = "GL_SAMPLER_2D_ARRAY_SHADOW_EXT"
	_GLenum_map[36293] = "GL_SAMPLER_CUBE_SHADOW"
	_GLenum_map[36293] = "GL_SAMPLER_CUBE_SHADOW_EXT"
	_GLenum_map[36293] = "GL_SAMPLER_CUBE_SHADOW_NV"
	_GLenum_map[36294] = "GL_UNSIGNED_INT_VEC2_EXT"
	_GLenum_map[36294] = "GL_UNSIGNED_INT_VEC2"
	_GLenum_map[36295] = "GL_UNSIGNED_INT_VEC3_EXT"
	_GLenum_map[36295] = "GL_UNSIGNED_INT_VEC3"
	_GLenum_map[36296] = "GL_UNSIGNED_INT_VEC4"
	_GLenum_map[36296] = "GL_UNSIGNED_INT_VEC4_EXT"
	_GLenum_map[36297] = "GL_INT_SAMPLER_1D_EXT"
	_GLenum_map[36297] = "GL_INT_SAMPLER_1D"
	_GLenum_map[36298] = "GL_INT_SAMPLER_2D"
	_GLenum_map[36298] = "GL_INT_SAMPLER_2D_EXT"
	_GLenum_map[36299] = "GL_INT_SAMPLER_3D"
	_GLenum_map[36299] = "GL_INT_SAMPLER_3D_EXT"
	_GLenum_map[36300] = "GL_INT_SAMPLER_CUBE"
	_GLenum_map[36300] = "GL_INT_SAMPLER_CUBE_EXT"
	_GLenum_map[36301] = "GL_INT_SAMPLER_2D_RECT"
	_GLenum_map[36301] = "GL_INT_SAMPLER_2D_RECT_EXT"
	_GLenum_map[36302] = "GL_INT_SAMPLER_1D_ARRAY"
	_GLenum_map[36302] = "GL_INT_SAMPLER_1D_ARRAY_EXT"
	_GLenum_map[36303] = "GL_INT_SAMPLER_2D_ARRAY"
	_GLenum_map[36303] = "GL_INT_SAMPLER_2D_ARRAY_EXT"
	_GLenum_map[36304] = "GL_INT_SAMPLER_BUFFER"
	_GLenum_map[36304] = "GL_INT_SAMPLER_BUFFER_OES"
	_GLenum_map[36304] = "GL_INT_SAMPLER_BUFFER_EXT"
	_GLenum_map[36305] = "GL_UNSIGNED_INT_SAMPLER_1D_EXT"
	_GLenum_map[36305] = "GL_UNSIGNED_INT_SAMPLER_1D"
	_GLenum_map[36306] = "GL_UNSIGNED_INT_SAMPLER_2D"
	_GLenum_map[36306] = "GL_UNSIGNED_INT_SAMPLER_2D_EXT"
	_GLenum_map[36307] = "GL_UNSIGNED_INT_SAMPLER_3D"
	_GLenum_map[36307] = "GL_UNSIGNED_INT_SAMPLER_3D_EXT"
	_GLenum_map[36308] = "GL_UNSIGNED_INT_SAMPLER_CUBE"
	_GLenum_map[36308] = "GL_UNSIGNED_INT_SAMPLER_CUBE_EXT"
	_GLenum_map[36309] = "GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT"
	_GLenum_map[36309] = "GL_UNSIGNED_INT_SAMPLER_2D_RECT"
	_GLenum_map[36310] = "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY"
	_GLenum_map[36310] = "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT"
	_GLenum_map[36311] = "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"
	_GLenum_map[36311] = "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT"
	_GLenum_map[36312] = "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT"
	_GLenum_map[36312] = "GL_UNSIGNED_INT_SAMPLER_BUFFER"
	_GLenum_map[36312] = "GL_UNSIGNED_INT_SAMPLER_BUFFER_OES"
	_GLenum_map[36313] = "GL_GEOMETRY_SHADER_EXT"
	_GLenum_map[36313] = "GL_GEOMETRY_SHADER_ARB"
	_GLenum_map[36313] = "GL_GEOMETRY_SHADER"
	_GLenum_map[36313] = "GL_GEOMETRY_SHADER_OES"
	_GLenum_map[36314] = "GL_GEOMETRY_VERTICES_OUT_EXT"
	_GLenum_map[36314] = "GL_GEOMETRY_VERTICES_OUT_ARB"
	_GLenum_map[36315] = "GL_GEOMETRY_INPUT_TYPE_ARB"
	_GLenum_map[36315] = "GL_GEOMETRY_INPUT_TYPE_EXT"
	_GLenum_map[36316] = "GL_GEOMETRY_OUTPUT_TYPE_ARB"
	_GLenum_map[36316] = "GL_GEOMETRY_OUTPUT_TYPE_EXT"
	_GLenum_map[36317] = "GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT"
	_GLenum_map[36317] = "GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB"
	_GLenum_map[36318] = "GL_MAX_VERTEX_VARYING_COMPONENTS_EXT"
	_GLenum_map[36318] = "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB"
	_GLenum_map[36319] = "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES"
	_GLenum_map[36319] = "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"
	_GLenum_map[36319] = "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB"
	_GLenum_map[36319] = "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[36320] = "GL_MAX_GEOMETRY_OUTPUT_VERTICES"
	_GLenum_map[36320] = "GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES"
	_GLenum_map[36320] = "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT"
	_GLenum_map[36320] = "GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB"
	_GLenum_map[36321] = "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES"
	_GLenum_map[36321] = "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT"
	_GLenum_map[36321] = "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS"
	_GLenum_map[36321] = "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB"
	_GLenum_map[36322] = "GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT"
	_GLenum_map[36323] = "GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT"
	_GLenum_map[36324] = "GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT"
	_GLenum_map[36325] = "GL_ACTIVE_SUBROUTINES"
	_GLenum_map[36326] = "GL_ACTIVE_SUBROUTINE_UNIFORMS"
	_GLenum_map[36327] = "GL_MAX_SUBROUTINES"
	_GLenum_map[36328] = "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS"
	_GLenum_map[36329] = "GL_NAMED_STRING_LENGTH_ARB"
	_GLenum_map[36330] = "GL_NAMED_STRING_TYPE_ARB"
	_GLenum_map[36333] = "GL_MAX_BINDABLE_UNIFORM_SIZE_EXT"
	_GLenum_map[36334] = "GL_UNIFORM_BUFFER_EXT"
	_GLenum_map[36335] = "GL_UNIFORM_BUFFER_BINDING_EXT"
	_GLenum_map[36336] = "GL_LOW_FLOAT"
	_GLenum_map[36337] = "GL_MEDIUM_FLOAT"
	_GLenum_map[36338] = "GL_HIGH_FLOAT"
	_GLenum_map[36339] = "GL_LOW_INT"
	_GLenum_map[36340] = "GL_MEDIUM_INT"
	_GLenum_map[36341] = "GL_HIGH_INT"
	_GLenum_map[36342] = "GL_UNSIGNED_INT_10_10_10_2_OES"
	_GLenum_map[36343] = "GL_INT_10_10_10_2_OES"
	_GLenum_map[36344] = "GL_SHADER_BINARY_FORMATS"
	_GLenum_map[36345] = "GL_NUM_SHADER_BINARY_FORMATS"
	_GLenum_map[36346] = "GL_SHADER_COMPILER"
	_GLenum_map[36347] = "GL_MAX_VERTEX_UNIFORM_VECTORS"
	_GLenum_map[36348] = "GL_MAX_VARYING_VECTORS"
	_GLenum_map[36349] = "GL_MAX_FRAGMENT_UNIFORM_VECTORS"
	_GLenum_map[36368] = "GL_RENDERBUFFER_COLOR_SAMPLES_NV"
	_GLenum_map[36369] = "GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV"
	_GLenum_map[36370] = "GL_MULTISAMPLE_COVERAGE_MODES_NV"
	_GLenum_map[36371] = "GL_QUERY_WAIT_NV"
	_GLenum_map[36371] = "GL_QUERY_WAIT"
	_GLenum_map[36372] = "GL_QUERY_NO_WAIT_NV"
	_GLenum_map[36372] = "GL_QUERY_NO_WAIT"
	_GLenum_map[36373] = "GL_QUERY_BY_REGION_WAIT"
	_GLenum_map[36373] = "GL_QUERY_BY_REGION_WAIT_NV"
	_GLenum_map[36374] = "GL_QUERY_BY_REGION_NO_WAIT"
	_GLenum_map[36374] = "GL_QUERY_BY_REGION_NO_WAIT_NV"
	_GLenum_map[36375] = "GL_QUERY_WAIT_INVERTED"
	_GLenum_map[36376] = "GL_QUERY_NO_WAIT_INVERTED"
	_GLenum_map[36377] = "GL_QUERY_BY_REGION_WAIT_INVERTED"
	_GLenum_map[36378] = "GL_QUERY_BY_REGION_NO_WAIT_INVERTED"
	_GLenum_map[36379] = "GL_POLYGON_OFFSET_CLAMP_EXT"
	_GLenum_map[36382] = "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES"
	_GLenum_map[36382] = "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[36382] = "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS"
	_GLenum_map[36383] = "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[36383] = "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES"
	_GLenum_map[36383] = "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS"
	_GLenum_map[36384] = "GL_COLOR_SAMPLES_NV"
	_GLenum_map[36386] = "GL_TRANSFORM_FEEDBACK"
	_GLenum_map[36386] = "GL_TRANSFORM_FEEDBACK_NV"
	_GLenum_map[36387] = "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV"
	_GLenum_map[36387] = "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED"
	_GLenum_map[36387] = "GL_TRANSFORM_FEEDBACK_PAUSED"
	_GLenum_map[36388] = "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE"
	_GLenum_map[36388] = "GL_TRANSFORM_FEEDBACK_ACTIVE"
	_GLenum_map[36388] = "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV"
	_GLenum_map[36389] = "GL_TRANSFORM_FEEDBACK_BINDING_NV"
	_GLenum_map[36389] = "GL_TRANSFORM_FEEDBACK_BINDING"
	_GLenum_map[36390] = "GL_FRAME_NV"
	_GLenum_map[36391] = "GL_FIELDS_NV"
	_GLenum_map[36392] = "GL_TIMESTAMP_EXT"
	_GLenum_map[36392] = "GL_CURRENT_TIME_NV"
	_GLenum_map[36392] = "GL_TIMESTAMP"
	_GLenum_map[36393] = "GL_NUM_FILL_STREAMS_NV"
	_GLenum_map[36394] = "GL_PRESENT_TIME_NV"
	_GLenum_map[36395] = "GL_PRESENT_DURATION_NV"
	_GLenum_map[36396] = "GL_DEPTH_COMPONENT16_NONLINEAR_NV"
	_GLenum_map[36397] = "GL_PROGRAM_MATRIX_EXT"
	_GLenum_map[36398] = "GL_TRANSPOSE_PROGRAM_MATRIX_EXT"
	_GLenum_map[36399] = "GL_PROGRAM_MATRIX_STACK_DEPTH_EXT"
	_GLenum_map[36418] = "GL_TEXTURE_SWIZZLE_R"
	_GLenum_map[36418] = "GL_TEXTURE_SWIZZLE_R_EXT"
	_GLenum_map[36419] = "GL_TEXTURE_SWIZZLE_G"
	_GLenum_map[36419] = "GL_TEXTURE_SWIZZLE_G_EXT"
	_GLenum_map[36420] = "GL_TEXTURE_SWIZZLE_B_EXT"
	_GLenum_map[36420] = "GL_TEXTURE_SWIZZLE_B"
	_GLenum_map[36421] = "GL_TEXTURE_SWIZZLE_A_EXT"
	_GLenum_map[36421] = "GL_TEXTURE_SWIZZLE_A"
	_GLenum_map[36422] = "GL_TEXTURE_SWIZZLE_RGBA_EXT"
	_GLenum_map[36422] = "GL_TEXTURE_SWIZZLE_RGBA"
	_GLenum_map[36423] = "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS"
	_GLenum_map[36424] = "GL_ACTIVE_SUBROUTINE_MAX_LENGTH"
	_GLenum_map[36425] = "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH"
	_GLenum_map[36426] = "GL_NUM_COMPATIBLE_SUBROUTINES"
	_GLenum_map[36427] = "GL_COMPATIBLE_SUBROUTINES"
	_GLenum_map[36428] = "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION"
	_GLenum_map[36428] = "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT"
	_GLenum_map[36429] = "GL_FIRST_VERTEX_CONVENTION_OES"
	_GLenum_map[36429] = "GL_FIRST_VERTEX_CONVENTION"
	_GLenum_map[36429] = "GL_FIRST_VERTEX_CONVENTION_EXT"
	_GLenum_map[36430] = "GL_LAST_VERTEX_CONVENTION_EXT"
	_GLenum_map[36430] = "GL_LAST_VERTEX_CONVENTION"
	_GLenum_map[36430] = "GL_LAST_VERTEX_CONVENTION_OES"
	_GLenum_map[36431] = "GL_PROVOKING_VERTEX"
	_GLenum_map[36431] = "GL_PROVOKING_VERTEX_EXT"
	_GLenum_map[36432] = "GL_SAMPLE_POSITION_NV"
	_GLenum_map[36432] = "GL_SAMPLE_POSITION"
	_GLenum_map[36432] = "GL_SAMPLE_LOCATION_NV"
	_GLenum_map[36433] = "GL_SAMPLE_MASK_NV"
	_GLenum_map[36433] = "GL_SAMPLE_MASK"
	_GLenum_map[36434] = "GL_SAMPLE_MASK_VALUE_NV"
	_GLenum_map[36434] = "GL_SAMPLE_MASK_VALUE"
	_GLenum_map[36435] = "GL_TEXTURE_BINDING_RENDERBUFFER_NV"
	_GLenum_map[36436] = "GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV"
	_GLenum_map[36437] = "GL_TEXTURE_RENDERBUFFER_NV"
	_GLenum_map[36438] = "GL_SAMPLER_RENDERBUFFER_NV"
	_GLenum_map[36439] = "GL_INT_SAMPLER_RENDERBUFFER_NV"
	_GLenum_map[36440] = "GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV"
	_GLenum_map[36441] = "GL_MAX_SAMPLE_MASK_WORDS_NV"
	_GLenum_map[36441] = "GL_MAX_SAMPLE_MASK_WORDS"
	_GLenum_map[36442] = "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT"
	_GLenum_map[36442] = "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES"
	_GLenum_map[36442] = "GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV"
	_GLenum_map[36442] = "GL_MAX_GEOMETRY_SHADER_INVOCATIONS"
	_GLenum_map[36443] = "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV"
	_GLenum_map[36443] = "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES"
	_GLenum_map[36443] = "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET"
	_GLenum_map[36444] = "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES"
	_GLenum_map[36444] = "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET"
	_GLenum_map[36444] = "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV"
	_GLenum_map[36445] = "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES"
	_GLenum_map[36445] = "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS"
	_GLenum_map[36445] = "GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV"
	_GLenum_map[36446] = "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET"
	_GLenum_map[36446] = "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB"
	_GLenum_map[36446] = "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV"
	_GLenum_map[36447] = "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB"
	_GLenum_map[36447] = "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET"
	_GLenum_map[36447] = "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV"
	_GLenum_map[36464] = "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS"
	_GLenum_map[36465] = "GL_MAX_VERTEX_STREAMS"
	_GLenum_map[36466] = "GL_PATCH_VERTICES_OES"
	_GLenum_map[36466] = "GL_PATCH_VERTICES"
	_GLenum_map[36466] = "GL_PATCH_VERTICES_EXT"
	_GLenum_map[36467] = "GL_PATCH_DEFAULT_INNER_LEVEL"
	_GLenum_map[36467] = "GL_PATCH_DEFAULT_INNER_LEVEL_EXT"
	_GLenum_map[36468] = "GL_PATCH_DEFAULT_OUTER_LEVEL"
	_GLenum_map[36468] = "GL_PATCH_DEFAULT_OUTER_LEVEL_EXT"
	_GLenum_map[36469] = "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT"
	_GLenum_map[36469] = "GL_TESS_CONTROL_OUTPUT_VERTICES"
	_GLenum_map[36469] = "GL_TESS_CONTROL_OUTPUT_VERTICES_OES"
	_GLenum_map[36470] = "GL_TESS_GEN_MODE_EXT"
	_GLenum_map[36470] = "GL_TESS_GEN_MODE_OES"
	_GLenum_map[36470] = "GL_TESS_GEN_MODE"
	_GLenum_map[36471] = "GL_TESS_GEN_SPACING_OES"
	_GLenum_map[36471] = "GL_TESS_GEN_SPACING_EXT"
	_GLenum_map[36471] = "GL_TESS_GEN_SPACING"
	_GLenum_map[36472] = "GL_TESS_GEN_VERTEX_ORDER_EXT"
	_GLenum_map[36472] = "GL_TESS_GEN_VERTEX_ORDER_OES"
	_GLenum_map[36472] = "GL_TESS_GEN_VERTEX_ORDER"
	_GLenum_map[36473] = "GL_TESS_GEN_POINT_MODE_EXT"
	_GLenum_map[36473] = "GL_TESS_GEN_POINT_MODE_OES"
	_GLenum_map[36473] = "GL_TESS_GEN_POINT_MODE"
	_GLenum_map[36474] = "GL_ISOLINES_EXT"
	_GLenum_map[36474] = "GL_ISOLINES_OES"
	_GLenum_map[36474] = "GL_ISOLINES"
	_GLenum_map[36475] = "GL_FRACTIONAL_ODD"
	_GLenum_map[36475] = "GL_FRACTIONAL_ODD_EXT"
	_GLenum_map[36475] = "GL_FRACTIONAL_ODD_OES"
	_GLenum_map[36476] = "GL_FRACTIONAL_EVEN"
	_GLenum_map[36476] = "GL_FRACTIONAL_EVEN_OES"
	_GLenum_map[36476] = "GL_FRACTIONAL_EVEN_EXT"
	_GLenum_map[36477] = "GL_MAX_PATCH_VERTICES_EXT"
	_GLenum_map[36477] = "GL_MAX_PATCH_VERTICES_OES"
	_GLenum_map[36477] = "GL_MAX_PATCH_VERTICES"
	_GLenum_map[36478] = "GL_MAX_TESS_GEN_LEVEL_OES"
	_GLenum_map[36478] = "GL_MAX_TESS_GEN_LEVEL"
	_GLenum_map[36478] = "GL_MAX_TESS_GEN_LEVEL_EXT"
	_GLenum_map[36479] = "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS"
	_GLenum_map[36479] = "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES"
	_GLenum_map[36479] = "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[36480] = "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES"
	_GLenum_map[36480] = "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT"
	_GLenum_map[36480] = "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS"
	_GLenum_map[36481] = "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES"
	_GLenum_map[36481] = "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS"
	_GLenum_map[36481] = "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT"
	_GLenum_map[36482] = "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS"
	_GLenum_map[36482] = "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT"
	_GLenum_map[36482] = "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES"
	_GLenum_map[36483] = "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES"
	_GLenum_map[36483] = "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS"
	_GLenum_map[36483] = "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT"
	_GLenum_map[36484] = "GL_MAX_TESS_PATCH_COMPONENTS_EXT"
	_GLenum_map[36484] = "GL_MAX_TESS_PATCH_COMPONENTS"
	_GLenum_map[36484] = "GL_MAX_TESS_PATCH_COMPONENTS_OES"
	_GLenum_map[36485] = "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT"
	_GLenum_map[36485] = "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES"
	_GLenum_map[36485] = "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS"
	_GLenum_map[36486] = "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS"
	_GLenum_map[36486] = "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES"
	_GLenum_map[36486] = "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT"
	_GLenum_map[36487] = "GL_TESS_EVALUATION_SHADER"
	_GLenum_map[36487] = "GL_TESS_EVALUATION_SHADER_EXT"
	_GLenum_map[36487] = "GL_TESS_EVALUATION_SHADER_OES"
	_GLenum_map[36488] = "GL_TESS_CONTROL_SHADER_EXT"
	_GLenum_map[36488] = "GL_TESS_CONTROL_SHADER_OES"
	_GLenum_map[36488] = "GL_TESS_CONTROL_SHADER"
	_GLenum_map[36489] = "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT"
	_GLenum_map[36489] = "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"
	_GLenum_map[36489] = "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES"
	_GLenum_map[36490] = "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES"
	_GLenum_map[36490] = "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT"
	_GLenum_map[36490] = "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"
	_GLenum_map[36492] = "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"
	_GLenum_map[36492] = "GL_COMPRESSED_RGBA_BPTC_UNORM"
	_GLenum_map[36493] = "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM"
	_GLenum_map[36493] = "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"
	_GLenum_map[36494] = "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT"
	_GLenum_map[36494] = "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"
	_GLenum_map[36495] = "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT"
	_GLenum_map[36495] = "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"
	_GLenum_map[36560] = "GL_COVERAGE_COMPONENT_NV"
	_GLenum_map[36561] = "GL_COVERAGE_COMPONENT4_NV"
	_GLenum_map[36562] = "GL_COVERAGE_ATTACHMENT_NV"
	_GLenum_map[36563] = "GL_COVERAGE_BUFFERS_NV"
	_GLenum_map[36564] = "GL_COVERAGE_SAMPLES_NV"
	_GLenum_map[36565] = "GL_COVERAGE_ALL_FRAGMENTS_NV"
	_GLenum_map[36566] = "GL_COVERAGE_EDGE_FRAGMENTS_NV"
	_GLenum_map[36567] = "GL_COVERAGE_AUTOMATIC_NV"
	_GLenum_map[36637] = "GL_BUFFER_GPU_ADDRESS_NV"
	_GLenum_map[36638] = "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV"
	_GLenum_map[36639] = "GL_ELEMENT_ARRAY_UNIFIED_NV"
	_GLenum_map[36640] = "GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV"
	_GLenum_map[36641] = "GL_VERTEX_ARRAY_ADDRESS_NV"
	_GLenum_map[36642] = "GL_NORMAL_ARRAY_ADDRESS_NV"
	_GLenum_map[36643] = "GL_COLOR_ARRAY_ADDRESS_NV"
	_GLenum_map[36644] = "GL_INDEX_ARRAY_ADDRESS_NV"
	_GLenum_map[36645] = "GL_TEXTURE_COORD_ARRAY_ADDRESS_NV"
	_GLenum_map[36646] = "GL_EDGE_FLAG_ARRAY_ADDRESS_NV"
	_GLenum_map[36647] = "GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV"
	_GLenum_map[36648] = "GL_FOG_COORD_ARRAY_ADDRESS_NV"
	_GLenum_map[36649] = "GL_ELEMENT_ARRAY_ADDRESS_NV"
	_GLenum_map[36650] = "GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV"
	_GLenum_map[36651] = "GL_VERTEX_ARRAY_LENGTH_NV"
	_GLenum_map[36652] = "GL_NORMAL_ARRAY_LENGTH_NV"
	_GLenum_map[36653] = "GL_COLOR_ARRAY_LENGTH_NV"
	_GLenum_map[36654] = "GL_INDEX_ARRAY_LENGTH_NV"
	_GLenum_map[36655] = "GL_TEXTURE_COORD_ARRAY_LENGTH_NV"
	_GLenum_map[36656] = "GL_EDGE_FLAG_ARRAY_LENGTH_NV"
	_GLenum_map[36657] = "GL_SECONDARY_COLOR_ARRAY_LENGTH_NV"
	_GLenum_map[36658] = "GL_FOG_COORD_ARRAY_LENGTH_NV"
	_GLenum_map[36659] = "GL_ELEMENT_ARRAY_LENGTH_NV"
	_GLenum_map[36660] = "GL_GPU_ADDRESS_NV"
	_GLenum_map[36661] = "GL_MAX_SHADER_BUFFER_ADDRESS_NV"
	_GLenum_map[36662] = "GL_COPY_READ_BUFFER_NV"
	_GLenum_map[36662] = "GL_COPY_READ_BUFFER_BINDING"
	_GLenum_map[36662] = "GL_COPY_READ_BUFFER"
	_GLenum_map[36663] = "GL_COPY_WRITE_BUFFER_NV"
	_GLenum_map[36663] = "GL_COPY_WRITE_BUFFER"
	_GLenum_map[36663] = "GL_COPY_WRITE_BUFFER_BINDING"
	_GLenum_map[36664] = "GL_MAX_IMAGE_UNITS_EXT"
	_GLenum_map[36664] = "GL_MAX_IMAGE_UNITS"
	_GLenum_map[36665] = "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS"
	_GLenum_map[36665] = "GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES"
	_GLenum_map[36665] = "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT"
	_GLenum_map[36666] = "GL_IMAGE_BINDING_NAME"
	_GLenum_map[36666] = "GL_IMAGE_BINDING_NAME_EXT"
	_GLenum_map[36667] = "GL_IMAGE_BINDING_LEVEL"
	_GLenum_map[36667] = "GL_IMAGE_BINDING_LEVEL_EXT"
	_GLenum_map[36668] = "GL_IMAGE_BINDING_LAYERED"
	_GLenum_map[36668] = "GL_IMAGE_BINDING_LAYERED_EXT"
	_GLenum_map[36669] = "GL_IMAGE_BINDING_LAYER_EXT"
	_GLenum_map[36669] = "GL_IMAGE_BINDING_LAYER"
	_GLenum_map[36670] = "GL_IMAGE_BINDING_ACCESS"
	_GLenum_map[36670] = "GL_IMAGE_BINDING_ACCESS_EXT"
	_GLenum_map[36671] = "GL_DRAW_INDIRECT_BUFFER"
	_GLenum_map[36672] = "GL_DRAW_INDIRECT_UNIFIED_NV"
	_GLenum_map[36673] = "GL_DRAW_INDIRECT_ADDRESS_NV"
	_GLenum_map[36674] = "GL_DRAW_INDIRECT_LENGTH_NV"
	_GLenum_map[36675] = "GL_DRAW_INDIRECT_BUFFER_BINDING"
	_GLenum_map[36676] = "GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV"
	_GLenum_map[36677] = "GL_MAX_PROGRAM_SUBROUTINE_NUM_NV"
	_GLenum_map[36678] = "GL_DOUBLE_MAT2_EXT"
	_GLenum_map[36678] = "GL_DOUBLE_MAT2"
	_GLenum_map[36679] = "GL_DOUBLE_MAT3_EXT"
	_GLenum_map[36679] = "GL_DOUBLE_MAT3"
	_GLenum_map[36680] = "GL_DOUBLE_MAT4_EXT"
	_GLenum_map[36680] = "GL_DOUBLE_MAT4"
	_GLenum_map[36681] = "GL_DOUBLE_MAT2x3_EXT"
	_GLenum_map[36681] = "GL_DOUBLE_MAT2x3"
	_GLenum_map[36682] = "GL_DOUBLE_MAT2x4_EXT"
	_GLenum_map[36682] = "GL_DOUBLE_MAT2x4"
	_GLenum_map[36683] = "GL_DOUBLE_MAT3x2"
	_GLenum_map[36683] = "GL_DOUBLE_MAT3x2_EXT"
	_GLenum_map[36684] = "GL_DOUBLE_MAT3x4_EXT"
	_GLenum_map[36684] = "GL_DOUBLE_MAT3x4"
	_GLenum_map[36685] = "GL_DOUBLE_MAT4x2"
	_GLenum_map[36685] = "GL_DOUBLE_MAT4x2_EXT"
	_GLenum_map[36686] = "GL_DOUBLE_MAT4x3_EXT"
	_GLenum_map[36686] = "GL_DOUBLE_MAT4x3"
	_GLenum_map[36687] = "GL_VERTEX_BINDING_BUFFER"
	_GLenum_map[36704] = "GL_MALI_SHADER_BINARY_ARM"
	_GLenum_map[36705] = "GL_MALI_PROGRAM_BINARY_ARM"
	_GLenum_map[36707] = "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT"
	_GLenum_map[36708] = "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT"
	_GLenum_map[36709] = "GL_FETCH_PER_SAMPLE_ARM"
	_GLenum_map[36710] = "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM"
	_GLenum_map[36711] = "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT"
	_GLenum_map[36752] = "GL_RED_SNORM"
	_GLenum_map[36753] = "GL_RG_SNORM"
	_GLenum_map[36754] = "GL_RGB_SNORM"
	_GLenum_map[36755] = "GL_RGBA_SNORM"
	_GLenum_map[36756] = "GL_R8_SNORM"
	_GLenum_map[36757] = "GL_RG8_SNORM"
	_GLenum_map[36758] = "GL_RGB8_SNORM"
	_GLenum_map[36759] = "GL_RGBA8_SNORM"
	_GLenum_map[36760] = "GL_R16_SNORM_EXT"
	_GLenum_map[36760] = "GL_R16_SNORM"
	_GLenum_map[36761] = "GL_RG16_SNORM"
	_GLenum_map[36761] = "GL_RG16_SNORM_EXT"
	_GLenum_map[36762] = "GL_RGB16_SNORM"
	_GLenum_map[36762] = "GL_RGB16_SNORM_EXT"
	_GLenum_map[36763] = "GL_RGBA16_SNORM_EXT"
	_GLenum_map[36763] = "GL_RGBA16_SNORM"
	_GLenum_map[36764] = "GL_SIGNED_NORMALIZED"
	_GLenum_map[36765] = "GL_PRIMITIVE_RESTART"
	_GLenum_map[36766] = "GL_PRIMITIVE_RESTART_INDEX"
	_GLenum_map[36767] = "GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB"
	_GLenum_map[36768] = "GL_PERFMON_GLOBAL_MODE_QCOM"
	_GLenum_map[36784] = "GL_BINNING_CONTROL_HINT_QCOM"
	_GLenum_map[36785] = "GL_CPU_OPTIMIZED_QCOM"
	_GLenum_map[36786] = "GL_GPU_OPTIMIZED_QCOM"
	_GLenum_map[36787] = "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM"
	_GLenum_map[36795] = "GL_GPU_DISJOINT_EXT"
	_GLenum_map[36797] = "GL_SR8_EXT"
	_GLenum_map[36798] = "GL_SRG8_EXT"
	_GLenum_map[36804] = "GL_SHADER_BINARY_VIV"
	_GLenum_map[36832] = "GL_INT8_NV"
	_GLenum_map[36833] = "GL_INT8_VEC2_NV"
	_GLenum_map[36834] = "GL_INT8_VEC3_NV"
	_GLenum_map[36835] = "GL_INT8_VEC4_NV"
	_GLenum_map[36836] = "GL_INT16_NV"
	_GLenum_map[36837] = "GL_INT16_VEC2_NV"
	_GLenum_map[36838] = "GL_INT16_VEC3_NV"
	_GLenum_map[36839] = "GL_INT16_VEC4_NV"
	_GLenum_map[36841] = "GL_INT64_VEC2_NV"
	_GLenum_map[36842] = "GL_INT64_VEC3_NV"
	_GLenum_map[36843] = "GL_INT64_VEC4_NV"
	_GLenum_map[36844] = "GL_UNSIGNED_INT8_NV"
	_GLenum_map[36845] = "GL_UNSIGNED_INT8_VEC2_NV"
	_GLenum_map[36846] = "GL_UNSIGNED_INT8_VEC3_NV"
	_GLenum_map[36847] = "GL_UNSIGNED_INT8_VEC4_NV"
	_GLenum_map[36848] = "GL_UNSIGNED_INT16_NV"
	_GLenum_map[36849] = "GL_UNSIGNED_INT16_VEC2_NV"
	_GLenum_map[36850] = "GL_UNSIGNED_INT16_VEC3_NV"
	_GLenum_map[36851] = "GL_UNSIGNED_INT16_VEC4_NV"
	_GLenum_map[36853] = "GL_UNSIGNED_INT64_VEC2_NV"
	_GLenum_map[36854] = "GL_UNSIGNED_INT64_VEC3_NV"
	_GLenum_map[36855] = "GL_UNSIGNED_INT64_VEC4_NV"
	_GLenum_map[36856] = "GL_FLOAT16_NV"
	_GLenum_map[36857] = "GL_FLOAT16_VEC2_NV"
	_GLenum_map[36858] = "GL_FLOAT16_VEC3_NV"
	_GLenum_map[36859] = "GL_FLOAT16_VEC4_NV"
	_GLenum_map[36860] = "GL_DOUBLE_VEC2"
	_GLenum_map[36860] = "GL_DOUBLE_VEC2_EXT"
	_GLenum_map[36861] = "GL_DOUBLE_VEC3_EXT"
	_GLenum_map[36861] = "GL_DOUBLE_VEC3"
	_GLenum_map[36862] = "GL_DOUBLE_VEC4_EXT"
	_GLenum_map[36862] = "GL_DOUBLE_VEC4"
	_GLenum_map[36865] = "GL_SAMPLER_BUFFER_AMD"
	_GLenum_map[36866] = "GL_INT_SAMPLER_BUFFER_AMD"
	_GLenum_map[36867] = "GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD"
	_GLenum_map[36868] = "GL_TESSELLATION_MODE_AMD"
	_GLenum_map[36869] = "GL_TESSELLATION_FACTOR_AMD"
	_GLenum_map[36870] = "GL_DISCRETE_AMD"
	_GLenum_map[36871] = "GL_CONTINUOUS_AMD"
	_GLenum_map[36873] = "GL_TEXTURE_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36873] = "GL_TEXTURE_CUBE_MAP_ARRAY"
	_GLenum_map[36873] = "GL_TEXTURE_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36873] = "GL_TEXTURE_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36874] = "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY"
	_GLenum_map[36874] = "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36874] = "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36874] = "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36875] = "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY"
	_GLenum_map[36875] = "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36876] = "GL_SAMPLER_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36876] = "GL_SAMPLER_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36876] = "GL_SAMPLER_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36876] = "GL_SAMPLER_CUBE_MAP_ARRAY"
	_GLenum_map[36877] = "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"
	_GLenum_map[36877] = "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT"
	_GLenum_map[36877] = "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES"
	_GLenum_map[36877] = "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB"
	_GLenum_map[36878] = "GL_INT_SAMPLER_CUBE_MAP_ARRAY"
	_GLenum_map[36878] = "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36878] = "GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36878] = "GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36879] = "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB"
	_GLenum_map[36879] = "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36879] = "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"
	_GLenum_map[36879] = "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36880] = "GL_ALPHA_SNORM"
	_GLenum_map[36881] = "GL_LUMINANCE_SNORM"
	_GLenum_map[36882] = "GL_LUMINANCE_ALPHA_SNORM"
	_GLenum_map[36883] = "GL_INTENSITY_SNORM"
	_GLenum_map[36884] = "GL_ALPHA8_SNORM"
	_GLenum_map[36885] = "GL_LUMINANCE8_SNORM"
	_GLenum_map[36886] = "GL_LUMINANCE8_ALPHA8_SNORM"
	_GLenum_map[36887] = "GL_INTENSITY8_SNORM"
	_GLenum_map[36888] = "GL_ALPHA16_SNORM"
	_GLenum_map[36889] = "GL_LUMINANCE16_SNORM"
	_GLenum_map[36890] = "GL_LUMINANCE16_ALPHA16_SNORM"
	_GLenum_map[36891] = "GL_INTENSITY16_SNORM"
	_GLenum_map[36892] = "GL_FACTOR_MIN_AMD"
	_GLenum_map[36893] = "GL_FACTOR_MAX_AMD"
	_GLenum_map[36894] = "GL_DEPTH_CLAMP_NEAR_AMD"
	_GLenum_map[36895] = "GL_DEPTH_CLAMP_FAR_AMD"
	_GLenum_map[36896] = "GL_VIDEO_BUFFER_NV"
	_GLenum_map[36897] = "GL_VIDEO_BUFFER_BINDING_NV"
	_GLenum_map[36898] = "GL_FIELD_UPPER_NV"
	_GLenum_map[36899] = "GL_FIELD_LOWER_NV"
	_GLenum_map[36900] = "GL_NUM_VIDEO_CAPTURE_STREAMS_NV"
	_GLenum_map[36901] = "GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV"
	_GLenum_map[36902] = "GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV"
	_GLenum_map[36903] = "GL_LAST_VIDEO_CAPTURE_STATUS_NV"
	_GLenum_map[36904] = "GL_VIDEO_BUFFER_PITCH_NV"
	_GLenum_map[36905] = "GL_VIDEO_COLOR_CONVERSION_MATRIX_NV"
	_GLenum_map[36906] = "GL_VIDEO_COLOR_CONVERSION_MAX_NV"
	_GLenum_map[36907] = "GL_VIDEO_COLOR_CONVERSION_MIN_NV"
	_GLenum_map[36908] = "GL_VIDEO_COLOR_CONVERSION_OFFSET_NV"
	_GLenum_map[36909] = "GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV"
	_GLenum_map[36910] = "GL_PARTIAL_SUCCESS_NV"
	_GLenum_map[36911] = "GL_SUCCESS_NV"
	_GLenum_map[36912] = "GL_FAILURE_NV"
	_GLenum_map[36913] = "GL_YCBYCR8_422_NV"
	_GLenum_map[36914] = "GL_YCBAYCR8A_4224_NV"
	_GLenum_map[36915] = "GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV"
	_GLenum_map[36916] = "GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV"
	_GLenum_map[36917] = "GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV"
	_GLenum_map[36918] = "GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV"
	_GLenum_map[36919] = "GL_Z4Y12Z4CB12Z4CR12_444_NV"
	_GLenum_map[36920] = "GL_VIDEO_CAPTURE_FRAME_WIDTH_NV"
	_GLenum_map[36921] = "GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV"
	_GLenum_map[36922] = "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV"
	_GLenum_map[36923] = "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV"
	_GLenum_map[36924] = "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV"
	_GLenum_map[36933] = "GL_TEXTURE_COVERAGE_SAMPLES_NV"
	_GLenum_map[36934] = "GL_TEXTURE_COLOR_SAMPLES_NV"
	_GLenum_map[36935] = "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX"
	_GLenum_map[36936] = "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX"
	_GLenum_map[36937] = "GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX"
	_GLenum_map[36938] = "GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX"
	_GLenum_map[36939] = "GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX"
	_GLenum_map[36940] = "GL_IMAGE_1D"
	_GLenum_map[36940] = "GL_IMAGE_1D_EXT"
	_GLenum_map[36941] = "GL_IMAGE_2D_EXT"
	_GLenum_map[36941] = "GL_IMAGE_2D"
	_GLenum_map[36942] = "GL_IMAGE_3D_EXT"
	_GLenum_map[36942] = "GL_IMAGE_3D"
	_GLenum_map[36943] = "GL_IMAGE_2D_RECT"
	_GLenum_map[36943] = "GL_IMAGE_2D_RECT_EXT"
	_GLenum_map[36944] = "GL_IMAGE_CUBE"
	_GLenum_map[36944] = "GL_IMAGE_CUBE_EXT"
	_GLenum_map[36945] = "GL_IMAGE_BUFFER_OES"
	_GLenum_map[36945] = "GL_IMAGE_BUFFER_EXT"
	_GLenum_map[36945] = "GL_IMAGE_BUFFER"
	_GLenum_map[36946] = "GL_IMAGE_1D_ARRAY_EXT"
	_GLenum_map[36946] = "GL_IMAGE_1D_ARRAY"
	_GLenum_map[36947] = "GL_IMAGE_2D_ARRAY"
	_GLenum_map[36947] = "GL_IMAGE_2D_ARRAY_EXT"
	_GLenum_map[36948] = "GL_IMAGE_CUBE_MAP_ARRAY"
	_GLenum_map[36948] = "GL_IMAGE_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36948] = "GL_IMAGE_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36949] = "GL_IMAGE_2D_MULTISAMPLE"
	_GLenum_map[36949] = "GL_IMAGE_2D_MULTISAMPLE_EXT"
	_GLenum_map[36950] = "GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"
	_GLenum_map[36950] = "GL_IMAGE_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[36951] = "GL_INT_IMAGE_1D"
	_GLenum_map[36951] = "GL_INT_IMAGE_1D_EXT"
	_GLenum_map[36952] = "GL_INT_IMAGE_2D"
	_GLenum_map[36952] = "GL_INT_IMAGE_2D_EXT"
	_GLenum_map[36953] = "GL_INT_IMAGE_3D"
	_GLenum_map[36953] = "GL_INT_IMAGE_3D_EXT"
	_GLenum_map[36954] = "GL_INT_IMAGE_2D_RECT"
	_GLenum_map[36954] = "GL_INT_IMAGE_2D_RECT_EXT"
	_GLenum_map[36955] = "GL_INT_IMAGE_CUBE_EXT"
	_GLenum_map[36955] = "GL_INT_IMAGE_CUBE"
	_GLenum_map[36956] = "GL_INT_IMAGE_BUFFER_OES"
	_GLenum_map[36956] = "GL_INT_IMAGE_BUFFER_EXT"
	_GLenum_map[36956] = "GL_INT_IMAGE_BUFFER"
	_GLenum_map[36957] = "GL_INT_IMAGE_1D_ARRAY"
	_GLenum_map[36957] = "GL_INT_IMAGE_1D_ARRAY_EXT"
	_GLenum_map[36958] = "GL_INT_IMAGE_2D_ARRAY"
	_GLenum_map[36958] = "GL_INT_IMAGE_2D_ARRAY_EXT"
	_GLenum_map[36959] = "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36959] = "GL_INT_IMAGE_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36959] = "GL_INT_IMAGE_CUBE_MAP_ARRAY"
	_GLenum_map[36960] = "GL_INT_IMAGE_2D_MULTISAMPLE_EXT"
	_GLenum_map[36960] = "GL_INT_IMAGE_2D_MULTISAMPLE"
	_GLenum_map[36961] = "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[36961] = "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"
	_GLenum_map[36962] = "GL_UNSIGNED_INT_IMAGE_1D_EXT"
	_GLenum_map[36962] = "GL_UNSIGNED_INT_IMAGE_1D"
	_GLenum_map[36963] = "GL_UNSIGNED_INT_IMAGE_2D_EXT"
	_GLenum_map[36963] = "GL_UNSIGNED_INT_IMAGE_2D"
	_GLenum_map[36964] = "GL_UNSIGNED_INT_IMAGE_3D_EXT"
	_GLenum_map[36964] = "GL_UNSIGNED_INT_IMAGE_3D"
	_GLenum_map[36965] = "GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT"
	_GLenum_map[36965] = "GL_UNSIGNED_INT_IMAGE_2D_RECT"
	_GLenum_map[36966] = "GL_UNSIGNED_INT_IMAGE_CUBE"
	_GLenum_map[36966] = "GL_UNSIGNED_INT_IMAGE_CUBE_EXT"
	_GLenum_map[36967] = "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT"
	_GLenum_map[36967] = "GL_UNSIGNED_INT_IMAGE_BUFFER_OES"
	_GLenum_map[36967] = "GL_UNSIGNED_INT_IMAGE_BUFFER"
	_GLenum_map[36968] = "GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT"
	_GLenum_map[36968] = "GL_UNSIGNED_INT_IMAGE_1D_ARRAY"
	_GLenum_map[36969] = "GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT"
	_GLenum_map[36969] = "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"
	_GLenum_map[36970] = "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT"
	_GLenum_map[36970] = "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES"
	_GLenum_map[36970] = "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"
	_GLenum_map[36971] = "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE"
	_GLenum_map[36971] = "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT"
	_GLenum_map[36972] = "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[36972] = "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"
	_GLenum_map[36973] = "GL_MAX_IMAGE_SAMPLES_EXT"
	_GLenum_map[36973] = "GL_MAX_IMAGE_SAMPLES"
	_GLenum_map[36974] = "GL_IMAGE_BINDING_FORMAT_EXT"
	_GLenum_map[36974] = "GL_IMAGE_BINDING_FORMAT"
	_GLenum_map[36975] = "GL_RGB10_A2UI"
	_GLenum_map[36976] = "GL_PATH_FORMAT_SVG_NV"
	_GLenum_map[36977] = "GL_PATH_FORMAT_PS_NV"
	_GLenum_map[36978] = "GL_STANDARD_FONT_NAME_NV"
	_GLenum_map[36979] = "GL_SYSTEM_FONT_NAME_NV"
	_GLenum_map[36980] = "GL_FILE_NAME_NV"
	_GLenum_map[36981] = "GL_PATH_STROKE_WIDTH_NV"
	_GLenum_map[36982] = "GL_PATH_END_CAPS_NV"
	_GLenum_map[36983] = "GL_PATH_INITIAL_END_CAP_NV"
	_GLenum_map[36984] = "GL_PATH_TERMINAL_END_CAP_NV"
	_GLenum_map[36985] = "GL_PATH_JOIN_STYLE_NV"
	_GLenum_map[36986] = "GL_PATH_MITER_LIMIT_NV"
	_GLenum_map[36987] = "GL_PATH_DASH_CAPS_NV"
	_GLenum_map[36988] = "GL_PATH_INITIAL_DASH_CAP_NV"
	_GLenum_map[36989] = "GL_PATH_TERMINAL_DASH_CAP_NV"
	_GLenum_map[36990] = "GL_PATH_DASH_OFFSET_NV"
	_GLenum_map[36991] = "GL_PATH_CLIENT_LENGTH_NV"
	_GLenum_map[36992] = "GL_PATH_FILL_MODE_NV"
	_GLenum_map[36993] = "GL_PATH_FILL_MASK_NV"
	_GLenum_map[36994] = "GL_PATH_FILL_COVER_MODE_NV"
	_GLenum_map[36995] = "GL_PATH_STROKE_COVER_MODE_NV"
	_GLenum_map[36996] = "GL_PATH_STROKE_MASK_NV"
	_GLenum_map[37000] = "GL_COUNT_UP_NV"
	_GLenum_map[37001] = "GL_COUNT_DOWN_NV"
	_GLenum_map[37002] = "GL_PATH_OBJECT_BOUNDING_BOX_NV"
	_GLenum_map[37003] = "GL_CONVEX_HULL_NV"
	_GLenum_map[37005] = "GL_BOUNDING_BOX_NV"
	_GLenum_map[37006] = "GL_TRANSLATE_X_NV"
	_GLenum_map[37007] = "GL_TRANSLATE_Y_NV"
	_GLenum_map[37008] = "GL_TRANSLATE_2D_NV"
	_GLenum_map[37009] = "GL_TRANSLATE_3D_NV"
	_GLenum_map[37010] = "GL_AFFINE_2D_NV"
	_GLenum_map[37012] = "GL_AFFINE_3D_NV"
	_GLenum_map[37014] = "GL_TRANSPOSE_AFFINE_2D_NV"
	_GLenum_map[37016] = "GL_TRANSPOSE_AFFINE_3D_NV"
	_GLenum_map[37018] = "GL_UTF8_NV"
	_GLenum_map[37019] = "GL_UTF16_NV"
	_GLenum_map[37020] = "GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV"
	_GLenum_map[37021] = "GL_PATH_COMMAND_COUNT_NV"
	_GLenum_map[37022] = "GL_PATH_COORD_COUNT_NV"
	_GLenum_map[37023] = "GL_PATH_DASH_ARRAY_COUNT_NV"
	_GLenum_map[37024] = "GL_PATH_COMPUTED_LENGTH_NV"
	_GLenum_map[37025] = "GL_PATH_FILL_BOUNDING_BOX_NV"
	_GLenum_map[37026] = "GL_PATH_STROKE_BOUNDING_BOX_NV"
	_GLenum_map[37027] = "GL_SQUARE_NV"
	_GLenum_map[37028] = "GL_ROUND_NV"
	_GLenum_map[37029] = "GL_TRIANGULAR_NV"
	_GLenum_map[37030] = "GL_BEVEL_NV"
	_GLenum_map[37031] = "GL_MITER_REVERT_NV"
	_GLenum_map[37032] = "GL_MITER_TRUNCATE_NV"
	_GLenum_map[37033] = "GL_SKIP_MISSING_GLYPH_NV"
	_GLenum_map[37034] = "GL_USE_MISSING_GLYPH_NV"
	_GLenum_map[37035] = "GL_PATH_ERROR_POSITION_NV"
	_GLenum_map[37036] = "GL_PATH_FOG_GEN_MODE_NV"
	_GLenum_map[37037] = "GL_ACCUM_ADJACENT_PAIRS_NV"
	_GLenum_map[37038] = "GL_ADJACENT_PAIRS_NV"
	_GLenum_map[37039] = "GL_FIRST_TO_REST_NV"
	_GLenum_map[37040] = "GL_PATH_GEN_MODE_NV"
	_GLenum_map[37041] = "GL_PATH_GEN_COEFF_NV"
	_GLenum_map[37042] = "GL_PATH_GEN_COLOR_FORMAT_NV"
	_GLenum_map[37043] = "GL_PATH_GEN_COMPONENTS_NV"
	_GLenum_map[37044] = "GL_PATH_DASH_OFFSET_RESET_NV"
	_GLenum_map[37045] = "GL_MOVE_TO_RESETS_NV"
	_GLenum_map[37046] = "GL_MOVE_TO_CONTINUES_NV"
	_GLenum_map[37047] = "GL_PATH_STENCIL_FUNC_NV"
	_GLenum_map[37048] = "GL_PATH_STENCIL_REF_NV"
	_GLenum_map[37049] = "GL_PATH_STENCIL_VALUE_MASK_NV"
	_GLenum_map[37050] = "GL_SCALED_RESOLVE_FASTEST_EXT"
	_GLenum_map[37051] = "GL_SCALED_RESOLVE_NICEST_EXT"
	_GLenum_map[37052] = "GL_MIN_MAP_BUFFER_ALIGNMENT"
	_GLenum_map[37053] = "GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV"
	_GLenum_map[37054] = "GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV"
	_GLenum_map[37055] = "GL_PATH_COVER_DEPTH_FUNC_NV"
	_GLenum_map[37063] = "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"
	_GLenum_map[37064] = "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE"
	_GLenum_map[37065] = "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS"
	_GLenum_map[37066] = "GL_MAX_VERTEX_IMAGE_UNIFORMS"
	_GLenum_map[37067] = "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS"
	_GLenum_map[37067] = "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT"
	_GLenum_map[37067] = "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES"
	_GLenum_map[37068] = "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES"
	_GLenum_map[37068] = "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS"
	_GLenum_map[37068] = "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT"
	_GLenum_map[37069] = "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT"
	_GLenum_map[37069] = "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES"
	_GLenum_map[37069] = "GL_MAX_GEOMETRY_IMAGE_UNIFORMS"
	_GLenum_map[37070] = "GL_MAX_FRAGMENT_IMAGE_UNIFORMS"
	_GLenum_map[37071] = "GL_MAX_COMBINED_IMAGE_UNIFORMS"
	_GLenum_map[37072] = "GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV"
	_GLenum_map[37073] = "GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV"
	_GLenum_map[37074] = "GL_SHADER_STORAGE_BUFFER"
	_GLenum_map[37075] = "GL_SHADER_STORAGE_BUFFER_BINDING"
	_GLenum_map[37076] = "GL_SHADER_STORAGE_BUFFER_START"
	_GLenum_map[37077] = "GL_SHADER_STORAGE_BUFFER_SIZE"
	_GLenum_map[37078] = "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37079] = "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37079] = "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT"
	_GLenum_map[37079] = "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES"
	_GLenum_map[37080] = "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES"
	_GLenum_map[37080] = "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT"
	_GLenum_map[37080] = "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37081] = "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37081] = "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES"
	_GLenum_map[37081] = "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT"
	_GLenum_map[37082] = "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37083] = "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37084] = "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"
	_GLenum_map[37085] = "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"
	_GLenum_map[37086] = "GL_MAX_SHADER_STORAGE_BLOCK_SIZE"
	_GLenum_map[37087] = "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"
	_GLenum_map[37089] = "GL_SYNC_X11_FENCE_EXT"
	_GLenum_map[37098] = "GL_DEPTH_STENCIL_TEXTURE_MODE"
	_GLenum_map[37099] = "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"
	_GLenum_map[37099] = "GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB"
	_GLenum_map[37100] = "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER"
	_GLenum_map[37101] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER"
	_GLenum_map[37102] = "GL_DISPATCH_INDIRECT_BUFFER"
	_GLenum_map[37103] = "GL_DISPATCH_INDIRECT_BUFFER_BINDING"
	_GLenum_map[37104] = "GL_COLOR_ATTACHMENT_EXT"
	_GLenum_map[37105] = "GL_MULTIVIEW_EXT"
	_GLenum_map[37106] = "GL_MAX_MULTIVIEW_BUFFERS_EXT"
	_GLenum_map[37107] = "GL_CONTEXT_ROBUST_ACCESS_EXT"
	_GLenum_map[37107] = "GL_CONTEXT_ROBUST_ACCESS_KHR"
	_GLenum_map[37107] = "GL_CONTEXT_ROBUST_ACCESS"
	_GLenum_map[37115] = "GL_COMPUTE_PROGRAM_NV"
	_GLenum_map[37116] = "GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV"
	_GLenum_map[37120] = "GL_TEXTURE_2D_MULTISAMPLE"
	_GLenum_map[37121] = "GL_PROXY_TEXTURE_2D_MULTISAMPLE"
	_GLenum_map[37122] = "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES"
	_GLenum_map[37122] = "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37123] = "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37124] = "GL_TEXTURE_BINDING_2D_MULTISAMPLE"
	_GLenum_map[37125] = "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES"
	_GLenum_map[37125] = "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37126] = "GL_TEXTURE_SAMPLES"
	_GLenum_map[37127] = "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS"
	_GLenum_map[37128] = "GL_SAMPLER_2D_MULTISAMPLE"
	_GLenum_map[37129] = "GL_INT_SAMPLER_2D_MULTISAMPLE"
	_GLenum_map[37130] = "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"
	_GLenum_map[37131] = "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37131] = "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES"
	_GLenum_map[37132] = "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES"
	_GLenum_map[37132] = "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37133] = "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"
	_GLenum_map[37133] = "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES"
	_GLenum_map[37134] = "GL_MAX_COLOR_TEXTURE_SAMPLES"
	_GLenum_map[37135] = "GL_MAX_DEPTH_TEXTURE_SAMPLES"
	_GLenum_map[37136] = "GL_MAX_INTEGER_SAMPLES"
	_GLenum_map[37137] = "GL_MAX_SERVER_WAIT_TIMEOUT"
	_GLenum_map[37137] = "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE"
	_GLenum_map[37138] = "GL_OBJECT_TYPE"
	_GLenum_map[37138] = "GL_OBJECT_TYPE_APPLE"
	_GLenum_map[37139] = "GL_SYNC_CONDITION"
	_GLenum_map[37139] = "GL_SYNC_CONDITION_APPLE"
	_GLenum_map[37140] = "GL_SYNC_STATUS"
	_GLenum_map[37140] = "GL_SYNC_STATUS_APPLE"
	_GLenum_map[37141] = "GL_SYNC_FLAGS_APPLE"
	_GLenum_map[37141] = "GL_SYNC_FLAGS"
	_GLenum_map[37142] = "GL_SYNC_FENCE_APPLE"
	_GLenum_map[37142] = "GL_SYNC_FENCE"
	_GLenum_map[37143] = "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE"
	_GLenum_map[37143] = "GL_SYNC_GPU_COMMANDS_COMPLETE"
	_GLenum_map[37144] = "GL_UNSIGNALED"
	_GLenum_map[37144] = "GL_UNSIGNALED_APPLE"
	_GLenum_map[37145] = "GL_SIGNALED"
	_GLenum_map[37145] = "GL_SIGNALED_APPLE"
	_GLenum_map[37146] = "GL_ALREADY_SIGNALED_APPLE"
	_GLenum_map[37146] = "GL_ALREADY_SIGNALED"
	_GLenum_map[37147] = "GL_TIMEOUT_EXPIRED"
	_GLenum_map[37147] = "GL_TIMEOUT_EXPIRED_APPLE"
	_GLenum_map[37148] = "GL_CONDITION_SATISFIED"
	_GLenum_map[37148] = "GL_CONDITION_SATISFIED_APPLE"
	_GLenum_map[37149] = "GL_WAIT_FAILED_APPLE"
	_GLenum_map[37149] = "GL_WAIT_FAILED"
	_GLenum_map[37151] = "GL_BUFFER_ACCESS_FLAGS"
	_GLenum_map[37152] = "GL_BUFFER_MAP_LENGTH"
	_GLenum_map[37153] = "GL_BUFFER_MAP_OFFSET"
	_GLenum_map[37154] = "GL_MAX_VERTEX_OUTPUT_COMPONENTS"
	_GLenum_map[37155] = "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT"
	_GLenum_map[37155] = "GL_MAX_GEOMETRY_INPUT_COMPONENTS"
	_GLenum_map[37155] = "GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES"
	_GLenum_map[37156] = "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT"
	_GLenum_map[37156] = "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"
	_GLenum_map[37156] = "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES"
	_GLenum_map[37157] = "GL_MAX_FRAGMENT_INPUT_COMPONENTS"
	_GLenum_map[37158] = "GL_CONTEXT_PROFILE_MASK"
	_GLenum_map[37159] = "GL_UNPACK_COMPRESSED_BLOCK_WIDTH"
	_GLenum_map[37160] = "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT"
	_GLenum_map[37161] = "GL_UNPACK_COMPRESSED_BLOCK_DEPTH"
	_GLenum_map[37162] = "GL_UNPACK_COMPRESSED_BLOCK_SIZE"
	_GLenum_map[37163] = "GL_PACK_COMPRESSED_BLOCK_WIDTH"
	_GLenum_map[37164] = "GL_PACK_COMPRESSED_BLOCK_HEIGHT"
	_GLenum_map[37165] = "GL_PACK_COMPRESSED_BLOCK_DEPTH"
	_GLenum_map[37166] = "GL_PACK_COMPRESSED_BLOCK_SIZE"
	_GLenum_map[37167] = "GL_TEXTURE_IMMUTABLE_FORMAT"
	_GLenum_map[37167] = "GL_TEXTURE_IMMUTABLE_FORMAT_EXT"
	_GLenum_map[37168] = "GL_SGX_PROGRAM_BINARY_IMG"
	_GLenum_map[37171] = "GL_RENDERBUFFER_SAMPLES_IMG"
	_GLenum_map[37172] = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG"
	_GLenum_map[37173] = "GL_MAX_SAMPLES_IMG"
	_GLenum_map[37174] = "GL_TEXTURE_SAMPLES_IMG"
	_GLenum_map[37175] = "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG"
	_GLenum_map[37176] = "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG"
	_GLenum_map[37187] = "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR"
	_GLenum_map[37187] = "GL_MAX_DEBUG_MESSAGE_LENGTH"
	_GLenum_map[37187] = "GL_MAX_DEBUG_MESSAGE_LENGTH_AMD"
	_GLenum_map[37187] = "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB"
	_GLenum_map[37188] = "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR"
	_GLenum_map[37188] = "GL_MAX_DEBUG_LOGGED_MESSAGES_AMD"
	_GLenum_map[37188] = "GL_MAX_DEBUG_LOGGED_MESSAGES"
	_GLenum_map[37188] = "GL_MAX_DEBUG_LOGGED_MESSAGES_ARB"
	_GLenum_map[37189] = "GL_DEBUG_LOGGED_MESSAGES"
	_GLenum_map[37189] = "GL_DEBUG_LOGGED_MESSAGES_AMD"
	_GLenum_map[37189] = "GL_DEBUG_LOGGED_MESSAGES_ARB"
	_GLenum_map[37189] = "GL_DEBUG_LOGGED_MESSAGES_KHR"
	_GLenum_map[37190] = "GL_DEBUG_SEVERITY_HIGH_AMD"
	_GLenum_map[37190] = "GL_DEBUG_SEVERITY_HIGH_ARB"
	_GLenum_map[37190] = "GL_DEBUG_SEVERITY_HIGH_KHR"
	_GLenum_map[37190] = "GL_DEBUG_SEVERITY_HIGH"
	_GLenum_map[37191] = "GL_DEBUG_SEVERITY_MEDIUM_ARB"
	_GLenum_map[37191] = "GL_DEBUG_SEVERITY_MEDIUM_AMD"
	_GLenum_map[37191] = "GL_DEBUG_SEVERITY_MEDIUM_KHR"
	_GLenum_map[37191] = "GL_DEBUG_SEVERITY_MEDIUM"
	_GLenum_map[37192] = "GL_DEBUG_SEVERITY_LOW_KHR"
	_GLenum_map[37192] = "GL_DEBUG_SEVERITY_LOW"
	_GLenum_map[37192] = "GL_DEBUG_SEVERITY_LOW_AMD"
	_GLenum_map[37192] = "GL_DEBUG_SEVERITY_LOW_ARB"
	_GLenum_map[37193] = "GL_DEBUG_CATEGORY_API_ERROR_AMD"
	_GLenum_map[37194] = "GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD"
	_GLenum_map[37195] = "GL_DEBUG_CATEGORY_DEPRECATION_AMD"
	_GLenum_map[37196] = "GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD"
	_GLenum_map[37197] = "GL_DEBUG_CATEGORY_PERFORMANCE_AMD"
	_GLenum_map[37198] = "GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD"
	_GLenum_map[37199] = "GL_DEBUG_CATEGORY_APPLICATION_AMD"
	_GLenum_map[37200] = "GL_DEBUG_CATEGORY_OTHER_AMD"
	_GLenum_map[37201] = "GL_DATA_BUFFER_AMD"
	_GLenum_map[37201] = "GL_BUFFER_OBJECT_EXT"
	_GLenum_map[37202] = "GL_PERFORMANCE_MONITOR_AMD"
	_GLenum_map[37203] = "GL_QUERY_OBJECT_AMD"
	_GLenum_map[37203] = "GL_QUERY_OBJECT_EXT"
	_GLenum_map[37204] = "GL_VERTEX_ARRAY_OBJECT_AMD"
	_GLenum_map[37204] = "GL_VERTEX_ARRAY_OBJECT_EXT"
	_GLenum_map[37205] = "GL_SAMPLER_OBJECT_AMD"
	_GLenum_map[37216] = "GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD"
	_GLenum_map[37266] = "GL_QUERY_BUFFER"
	_GLenum_map[37266] = "GL_QUERY_BUFFER_AMD"
	_GLenum_map[37267] = "GL_QUERY_BUFFER_BINDING_AMD"
	_GLenum_map[37267] = "GL_QUERY_BUFFER_BINDING"
	_GLenum_map[37268] = "GL_QUERY_RESULT_NO_WAIT"
	_GLenum_map[37268] = "GL_QUERY_RESULT_NO_WAIT_AMD"
	_GLenum_map[37269] = "GL_VIRTUAL_PAGE_SIZE_X_AMD"
	_GLenum_map[37269] = "GL_VIRTUAL_PAGE_SIZE_X_ARB"
	_GLenum_map[37269] = "GL_VIRTUAL_PAGE_SIZE_X_EXT"
	_GLenum_map[37270] = "GL_VIRTUAL_PAGE_SIZE_Y_AMD"
	_GLenum_map[37270] = "GL_VIRTUAL_PAGE_SIZE_Y_EXT"
	_GLenum_map[37270] = "GL_VIRTUAL_PAGE_SIZE_Y_ARB"
	_GLenum_map[37271] = "GL_VIRTUAL_PAGE_SIZE_Z_EXT"
	_GLenum_map[37271] = "GL_VIRTUAL_PAGE_SIZE_Z_ARB"
	_GLenum_map[37271] = "GL_VIRTUAL_PAGE_SIZE_Z_AMD"
	_GLenum_map[37272] = "GL_MAX_SPARSE_TEXTURE_SIZE_ARB"
	_GLenum_map[37272] = "GL_MAX_SPARSE_TEXTURE_SIZE_EXT"
	_GLenum_map[37272] = "GL_MAX_SPARSE_TEXTURE_SIZE_AMD"
	_GLenum_map[37273] = "GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD"
	_GLenum_map[37273] = "GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB"
	_GLenum_map[37273] = "GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT"
	_GLenum_map[37274] = "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT"
	_GLenum_map[37274] = "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS"
	_GLenum_map[37274] = "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB"
	_GLenum_map[37275] = "GL_MIN_SPARSE_LEVEL_AMD"
	_GLenum_map[37276] = "GL_MIN_LOD_WARNING_AMD"
	_GLenum_map[37277] = "GL_TEXTURE_BUFFER_OFFSET"
	_GLenum_map[37277] = "GL_TEXTURE_BUFFER_OFFSET_OES"
	_GLenum_map[37277] = "GL_TEXTURE_BUFFER_OFFSET_EXT"
	_GLenum_map[37278] = "GL_TEXTURE_BUFFER_SIZE"
	_GLenum_map[37278] = "GL_TEXTURE_BUFFER_SIZE_OES"
	_GLenum_map[37278] = "GL_TEXTURE_BUFFER_SIZE_EXT"
	_GLenum_map[37279] = "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT"
	_GLenum_map[37279] = "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"
	_GLenum_map[37279] = "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES"
	_GLenum_map[37280] = "GL_STREAM_RASTERIZATION_AMD"
	_GLenum_map[37284] = "GL_VERTEX_ELEMENT_SWIZZLE_AMD"
	_GLenum_map[37285] = "GL_VERTEX_ID_SWIZZLE_AMD"
	_GLenum_map[37286] = "GL_TEXTURE_SPARSE_EXT"
	_GLenum_map[37286] = "GL_TEXTURE_SPARSE_ARB"
	_GLenum_map[37287] = "GL_VIRTUAL_PAGE_SIZE_INDEX_ARB"
	_GLenum_map[37287] = "GL_VIRTUAL_PAGE_SIZE_INDEX_EXT"
	_GLenum_map[37288] = "GL_NUM_VIRTUAL_PAGE_SIZES_EXT"
	_GLenum_map[37288] = "GL_NUM_VIRTUAL_PAGE_SIZES_ARB"
	_GLenum_map[37289] = "GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT"
	_GLenum_map[37289] = "GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB"
	_GLenum_map[37290] = "GL_NUM_SPARSE_LEVELS_EXT"
	_GLenum_map[37290] = "GL_NUM_SPARSE_LEVELS_ARB"
	_GLenum_map[37305] = "GL_COMPUTE_SHADER"
	_GLenum_map[37307] = "GL_MAX_COMPUTE_UNIFORM_BLOCKS"
	_GLenum_map[37308] = "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"
	_GLenum_map[37309] = "GL_MAX_COMPUTE_IMAGE_UNIFORMS"
	_GLenum_map[37310] = "GL_MAX_COMPUTE_WORK_GROUP_COUNT"
	_GLenum_map[37311] = "GL_MAX_COMPUTE_WORK_GROUP_SIZE"
	_GLenum_map[37311] = "GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB"
	_GLenum_map[37440] = "GL_UNPACK_FLIP_Y_WEBGL"
	_GLenum_map[37441] = "GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL"
	_GLenum_map[37442] = "GL_CONTEXT_LOST_WEBGL"
	_GLenum_map[37443] = "GL_UNPACK_COLORSPACE_CONVERSION_WEBGL"
	_GLenum_map[37444] = "GL_BROWSER_DEFAULT_WEBGL"
	_GLenum_map[37456] = "GL_SHADER_BINARY_DMP"
	_GLenum_map[37457] = "GL_SMAPHS30_PROGRAM_BINARY_DMP"
	_GLenum_map[37458] = "GL_SMAPHS_PROGRAM_BINARY_DMP"
	_GLenum_map[37459] = "GL_DMP_PROGRAM_BINARY_DMP"
	_GLenum_map[37472] = "GL_GCCSO_SHADER_BINARY_FJ"
	_GLenum_map[37488] = "GL_COMPRESSED_R11_EAC_OES"
	_GLenum_map[37488] = "GL_COMPRESSED_R11_EAC"
	_GLenum_map[37489] = "GL_COMPRESSED_SIGNED_R11_EAC"
	_GLenum_map[37489] = "GL_COMPRESSED_SIGNED_R11_EAC_OES"
	_GLenum_map[37490] = "GL_COMPRESSED_RG11_EAC"
	_GLenum_map[37490] = "GL_COMPRESSED_RG11_EAC_OES"
	_GLenum_map[37491] = "GL_COMPRESSED_SIGNED_RG11_EAC"
	_GLenum_map[37491] = "GL_COMPRESSED_SIGNED_RG11_EAC_OES"
	_GLenum_map[37492] = "GL_COMPRESSED_RGB8_ETC2_OES"
	_GLenum_map[37492] = "GL_COMPRESSED_RGB8_ETC2"
	_GLenum_map[37493] = "GL_COMPRESSED_SRGB8_ETC2"
	_GLenum_map[37493] = "GL_COMPRESSED_SRGB8_ETC2_OES"
	_GLenum_map[37494] = "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES"
	_GLenum_map[37494] = "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"
	_GLenum_map[37495] = "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES"
	_GLenum_map[37495] = "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"
	_GLenum_map[37496] = "GL_COMPRESSED_RGBA8_ETC2_EAC"
	_GLenum_map[37496] = "GL_COMPRESSED_RGBA8_ETC2_EAC_OES"
	_GLenum_map[37497] = "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"
	_GLenum_map[37497] = "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES"
	_GLenum_map[37504] = "GL_BLEND_PREMULTIPLIED_SRC_NV"
	_GLenum_map[37505] = "GL_BLEND_OVERLAP_NV"
	_GLenum_map[37506] = "GL_UNCORRELATED_NV"
	_GLenum_map[37507] = "GL_DISJOINT_NV"
	_GLenum_map[37508] = "GL_CONJOINT_NV"
	_GLenum_map[37509] = "GL_BLEND_ADVANCED_COHERENT_NV"
	_GLenum_map[37509] = "GL_BLEND_ADVANCED_COHERENT_KHR"
	_GLenum_map[37510] = "GL_SRC_NV"
	_GLenum_map[37511] = "GL_DST_NV"
	_GLenum_map[37512] = "GL_SRC_OVER_NV"
	_GLenum_map[37513] = "GL_DST_OVER_NV"
	_GLenum_map[37514] = "GL_SRC_IN_NV"
	_GLenum_map[37515] = "GL_DST_IN_NV"
	_GLenum_map[37516] = "GL_SRC_OUT_NV"
	_GLenum_map[37517] = "GL_DST_OUT_NV"
	_GLenum_map[37518] = "GL_SRC_ATOP_NV"
	_GLenum_map[37519] = "GL_DST_ATOP_NV"
	_GLenum_map[37521] = "GL_PLUS_NV"
	_GLenum_map[37522] = "GL_PLUS_DARKER_NV"
	_GLenum_map[37524] = "GL_MULTIPLY_NV"
	_GLenum_map[37524] = "GL_MULTIPLY_KHR"
	_GLenum_map[37525] = "GL_SCREEN_KHR"
	_GLenum_map[37525] = "GL_SCREEN_NV"
	_GLenum_map[37526] = "GL_OVERLAY_KHR"
	_GLenum_map[37526] = "GL_OVERLAY_NV"
	_GLenum_map[37527] = "GL_DARKEN_NV"
	_GLenum_map[37527] = "GL_DARKEN_KHR"
	_GLenum_map[37528] = "GL_LIGHTEN_NV"
	_GLenum_map[37528] = "GL_LIGHTEN_KHR"
	_GLenum_map[37529] = "GL_COLORDODGE_NV"
	_GLenum_map[37529] = "GL_COLORDODGE_KHR"
	_GLenum_map[37530] = "GL_COLORBURN_KHR"
	_GLenum_map[37530] = "GL_COLORBURN_NV"
	_GLenum_map[37531] = "GL_HARDLIGHT_KHR"
	_GLenum_map[37531] = "GL_HARDLIGHT_NV"
	_GLenum_map[37532] = "GL_SOFTLIGHT_NV"
	_GLenum_map[37532] = "GL_SOFTLIGHT_KHR"
	_GLenum_map[37534] = "GL_DIFFERENCE_NV"
	_GLenum_map[37534] = "GL_DIFFERENCE_KHR"
	_GLenum_map[37535] = "GL_MINUS_NV"
	_GLenum_map[37536] = "GL_EXCLUSION_NV"
	_GLenum_map[37536] = "GL_EXCLUSION_KHR"
	_GLenum_map[37537] = "GL_CONTRAST_NV"
	_GLenum_map[37539] = "GL_INVERT_RGB_NV"
	_GLenum_map[37540] = "GL_LINEARDODGE_NV"
	_GLenum_map[37541] = "GL_LINEARBURN_NV"
	_GLenum_map[37542] = "GL_VIVIDLIGHT_NV"
	_GLenum_map[37543] = "GL_LINEARLIGHT_NV"
	_GLenum_map[37544] = "GL_PINLIGHT_NV"
	_GLenum_map[37545] = "GL_HARDMIX_NV"
	_GLenum_map[37549] = "GL_HSL_HUE_KHR"
	_GLenum_map[37549] = "GL_HSL_HUE_NV"
	_GLenum_map[37550] = "GL_HSL_SATURATION_NV"
	_GLenum_map[37550] = "GL_HSL_SATURATION_KHR"
	_GLenum_map[37551] = "GL_HSL_COLOR_KHR"
	_GLenum_map[37551] = "GL_HSL_COLOR_NV"
	_GLenum_map[37552] = "GL_HSL_LUMINOSITY_NV"
	_GLenum_map[37552] = "GL_HSL_LUMINOSITY_KHR"
	_GLenum_map[37553] = "GL_PLUS_CLAMPED_NV"
	_GLenum_map[37554] = "GL_PLUS_CLAMPED_ALPHA_NV"
	_GLenum_map[37555] = "GL_MINUS_CLAMPED_NV"
	_GLenum_map[37556] = "GL_INVERT_OVG_NV"
	_GLenum_map[37566] = "GL_PRIMITIVE_BOUNDING_BOX_EXT"
	_GLenum_map[37566] = "GL_PRIMITIVE_BOUNDING_BOX_OES"
	_GLenum_map[37568] = "GL_ATOMIC_COUNTER_BUFFER"
	_GLenum_map[37569] = "GL_ATOMIC_COUNTER_BUFFER_BINDING"
	_GLenum_map[37570] = "GL_ATOMIC_COUNTER_BUFFER_START"
	_GLenum_map[37571] = "GL_ATOMIC_COUNTER_BUFFER_SIZE"
	_GLenum_map[37572] = "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE"
	_GLenum_map[37573] = "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS"
	_GLenum_map[37574] = "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES"
	_GLenum_map[37575] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER"
	_GLenum_map[37576] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER"
	_GLenum_map[37577] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER"
	_GLenum_map[37578] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER"
	_GLenum_map[37579] = "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER"
	_GLenum_map[37580] = "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37581] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT"
	_GLenum_map[37581] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES"
	_GLenum_map[37581] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37582] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES"
	_GLenum_map[37582] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37582] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT"
	_GLenum_map[37583] = "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37583] = "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT"
	_GLenum_map[37583] = "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES"
	_GLenum_map[37584] = "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37585] = "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37586] = "GL_MAX_VERTEX_ATOMIC_COUNTERS"
	_GLenum_map[37587] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT"
	_GLenum_map[37587] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES"
	_GLenum_map[37587] = "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"
	_GLenum_map[37588] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT"
	_GLenum_map[37588] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES"
	_GLenum_map[37588] = "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"
	_GLenum_map[37589] = "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES"
	_GLenum_map[37589] = "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT"
	_GLenum_map[37589] = "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"
	_GLenum_map[37590] = "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"
	_GLenum_map[37591] = "GL_MAX_COMBINED_ATOMIC_COUNTERS"
	_GLenum_map[37592] = "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE"
	_GLenum_map[37593] = "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"
	_GLenum_map[37594] = "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX"
	_GLenum_map[37595] = "GL_UNSIGNED_INT_ATOMIC_COUNTER"
	_GLenum_map[37596] = "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS"
	_GLenum_map[37597] = "GL_FRAGMENT_COVERAGE_TO_COLOR_NV"
	_GLenum_map[37598] = "GL_FRAGMENT_COVERAGE_COLOR_NV"
	_GLenum_map[37600] = "GL_DEBUG_OUTPUT_KHR"
	_GLenum_map[37600] = "GL_DEBUG_OUTPUT"
	_GLenum_map[37601] = "GL_UNIFORM"
	_GLenum_map[37602] = "GL_UNIFORM_BLOCK"
	_GLenum_map[37603] = "GL_PROGRAM_INPUT"
	_GLenum_map[37604] = "GL_PROGRAM_OUTPUT"
	_GLenum_map[37605] = "GL_BUFFER_VARIABLE"
	_GLenum_map[37606] = "GL_SHADER_STORAGE_BLOCK"
	_GLenum_map[37607] = "GL_IS_PER_PATCH_OES"
	_GLenum_map[37607] = "GL_IS_PER_PATCH"
	_GLenum_map[37607] = "GL_IS_PER_PATCH_EXT"
	_GLenum_map[37608] = "GL_VERTEX_SUBROUTINE"
	_GLenum_map[37609] = "GL_TESS_CONTROL_SUBROUTINE"
	_GLenum_map[37610] = "GL_TESS_EVALUATION_SUBROUTINE"
	_GLenum_map[37611] = "GL_GEOMETRY_SUBROUTINE"
	_GLenum_map[37612] = "GL_FRAGMENT_SUBROUTINE"
	_GLenum_map[37613] = "GL_COMPUTE_SUBROUTINE"
	_GLenum_map[37614] = "GL_VERTEX_SUBROUTINE_UNIFORM"
	_GLenum_map[37615] = "GL_TESS_CONTROL_SUBROUTINE_UNIFORM"
	_GLenum_map[37616] = "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM"
	_GLenum_map[37617] = "GL_GEOMETRY_SUBROUTINE_UNIFORM"
	_GLenum_map[37618] = "GL_FRAGMENT_SUBROUTINE_UNIFORM"
	_GLenum_map[37619] = "GL_COMPUTE_SUBROUTINE_UNIFORM"
	_GLenum_map[37620] = "GL_TRANSFORM_FEEDBACK_VARYING"
	_GLenum_map[37621] = "GL_ACTIVE_RESOURCES"
	_GLenum_map[37622] = "GL_MAX_NAME_LENGTH"
	_GLenum_map[37623] = "GL_MAX_NUM_ACTIVE_VARIABLES"
	_GLenum_map[37624] = "GL_MAX_NUM_COMPATIBLE_SUBROUTINES"
	_GLenum_map[37625] = "GL_NAME_LENGTH"
	_GLenum_map[37626] = "GL_TYPE"
	_GLenum_map[37627] = "GL_ARRAY_SIZE"
	_GLenum_map[37628] = "GL_OFFSET"
	_GLenum_map[37629] = "GL_BLOCK_INDEX"
	_GLenum_map[37630] = "GL_ARRAY_STRIDE"
	_GLenum_map[37631] = "GL_MATRIX_STRIDE"
	_GLenum_map[37632] = "GL_IS_ROW_MAJOR"
	_GLenum_map[37633] = "GL_ATOMIC_COUNTER_BUFFER_INDEX"
	_GLenum_map[37634] = "GL_BUFFER_BINDING"
	_GLenum_map[37635] = "GL_BUFFER_DATA_SIZE"
	_GLenum_map[37636] = "GL_NUM_ACTIVE_VARIABLES"
	_GLenum_map[37637] = "GL_ACTIVE_VARIABLES"
	_GLenum_map[37638] = "GL_REFERENCED_BY_VERTEX_SHADER"
	_GLenum_map[37639] = "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT"
	_GLenum_map[37639] = "GL_REFERENCED_BY_TESS_CONTROL_SHADER"
	_GLenum_map[37639] = "GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES"
	_GLenum_map[37640] = "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT"
	_GLenum_map[37640] = "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"
	_GLenum_map[37640] = "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES"
	_GLenum_map[37641] = "GL_REFERENCED_BY_GEOMETRY_SHADER"
	_GLenum_map[37641] = "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT"
	_GLenum_map[37641] = "GL_REFERENCED_BY_GEOMETRY_SHADER_OES"
	_GLenum_map[37642] = "GL_REFERENCED_BY_FRAGMENT_SHADER"
	_GLenum_map[37643] = "GL_REFERENCED_BY_COMPUTE_SHADER"
	_GLenum_map[37644] = "GL_TOP_LEVEL_ARRAY_SIZE"
	_GLenum_map[37645] = "GL_TOP_LEVEL_ARRAY_STRIDE"
	_GLenum_map[37646] = "GL_LOCATION"
	_GLenum_map[37647] = "GL_LOCATION_INDEX"
	_GLenum_map[37648] = "GL_FRAMEBUFFER_DEFAULT_WIDTH"
	_GLenum_map[37649] = "GL_FRAMEBUFFER_DEFAULT_HEIGHT"
	_GLenum_map[37650] = "GL_FRAMEBUFFER_DEFAULT_LAYERS_OES"
	_GLenum_map[37650] = "GL_FRAMEBUFFER_DEFAULT_LAYERS"
	_GLenum_map[37650] = "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT"
	_GLenum_map[37651] = "GL_FRAMEBUFFER_DEFAULT_SAMPLES"
	_GLenum_map[37652] = "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"
	_GLenum_map[37653] = "GL_MAX_FRAMEBUFFER_WIDTH"
	_GLenum_map[37654] = "GL_MAX_FRAMEBUFFER_HEIGHT"
	_GLenum_map[37655] = "GL_MAX_FRAMEBUFFER_LAYERS"
	_GLenum_map[37655] = "GL_MAX_FRAMEBUFFER_LAYERS_EXT"
	_GLenum_map[37655] = "GL_MAX_FRAMEBUFFER_LAYERS_OES"
	_GLenum_map[37656] = "GL_MAX_FRAMEBUFFER_SAMPLES"
	_GLenum_map[37671] = "GL_RASTER_MULTISAMPLE_EXT"
	_GLenum_map[37672] = "GL_RASTER_SAMPLES_EXT"
	_GLenum_map[37673] = "GL_MAX_RASTER_SAMPLES_EXT"
	_GLenum_map[37674] = "GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT"
	_GLenum_map[37675] = "GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT"
	_GLenum_map[37676] = "GL_EFFECTIVE_RASTER_SAMPLES_EXT"
	_GLenum_map[37677] = "GL_DEPTH_SAMPLES_NV"
	_GLenum_map[37678] = "GL_STENCIL_SAMPLES_NV"
	_GLenum_map[37679] = "GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV"
	_GLenum_map[37680] = "GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV"
	_GLenum_map[37681] = "GL_COVERAGE_MODULATION_TABLE_NV"
	_GLenum_map[37682] = "GL_COVERAGE_MODULATION_NV"
	_GLenum_map[37683] = "GL_COVERAGE_MODULATION_TABLE_SIZE_NV"
	_GLenum_map[37689] = "GL_WARP_SIZE_NV"
	_GLenum_map[37690] = "GL_WARPS_PER_SM_NV"
	_GLenum_map[37691] = "GL_SM_COUNT_NV"
	_GLenum_map[37692] = "GL_FILL_RECTANGLE_NV"
	_GLenum_map[37693] = "GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV"
	_GLenum_map[37694] = "GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV"
	_GLenum_map[37695] = "GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV"
	_GLenum_map[37696] = "GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV"
	_GLenum_map[37697] = "GL_PROGRAMMABLE_SAMPLE_LOCATION_NV"
	_GLenum_map[37698] = "GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV"
	_GLenum_map[37699] = "GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV"
	_GLenum_map[37700] = "GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB"
	_GLenum_map[37701] = "GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB"
	_GLenum_map[37702] = "GL_CONSERVATIVE_RASTERIZATION_NV"
	_GLenum_map[37703] = "GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV"
	_GLenum_map[37704] = "GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV"
	_GLenum_map[37705] = "GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV"
	_GLenum_map[37706] = "GL_LOCATION_COMPONENT"
	_GLenum_map[37707] = "GL_TRANSFORM_FEEDBACK_BUFFER_INDEX"
	_GLenum_map[37708] = "GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE"
	_GLenum_map[37724] = "GL_CLIP_ORIGIN"
	_GLenum_map[37725] = "GL_CLIP_DEPTH_MODE"
	_GLenum_map[37726] = "GL_NEGATIVE_ONE_TO_ONE"
	_GLenum_map[37727] = "GL_ZERO_TO_ONE"
	_GLenum_map[37733] = "GL_CLEAR_TEXTURE"
	_GLenum_map[37736] = "GL_FONT_GLYPHS_AVAILABLE_NV"
	_GLenum_map[37737] = "GL_FONT_TARGET_UNAVAILABLE_NV"
	_GLenum_map[37738] = "GL_FONT_UNAVAILABLE_NV"
	_GLenum_map[37739] = "GL_FONT_UNINTELLIGIBLE_NV"
	_GLenum_map[37740] = "GL_STANDARD_FONT_FORMAT_NV"
	_GLenum_map[37741] = "GL_FRAGMENT_INPUT_NV"
	_GLenum_map[37742] = "GL_UNIFORM_BUFFER_UNIFIED_NV"
	_GLenum_map[37743] = "GL_UNIFORM_BUFFER_ADDRESS_NV"
	_GLenum_map[37744] = "GL_UNIFORM_BUFFER_LENGTH_NV"
	_GLenum_map[37745] = "GL_MULTISAMPLES_NV"
	_GLenum_map[37746] = "GL_SUPERSAMPLE_SCALE_X_NV"
	_GLenum_map[37747] = "GL_SUPERSAMPLE_SCALE_Y_NV"
	_GLenum_map[37748] = "GL_CONFORMANT_NV"
	_GLenum_map[37760] = "GL_NUM_SAMPLE_COUNTS"
	_GLenum_map[37792] = "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE"
	_GLenum_map[37793] = "GL_BGRA8_EXT"
	_GLenum_map[37794] = "GL_TEXTURE_USAGE_ANGLE"
	_GLenum_map[37795] = "GL_FRAMEBUFFER_ATTACHMENT_ANGLE"
	_GLenum_map[37796] = "GL_PACK_REVERSE_ROW_ORDER_ANGLE"
	_GLenum_map[37798] = "GL_PROGRAM_BINARY_ANGLE"
	_GLenum_map[37808] = "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"
	_GLenum_map[37809] = "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"
	_GLenum_map[37810] = "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"
	_GLenum_map[37811] = "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"
	_GLenum_map[37812] = "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"
	_GLenum_map[37813] = "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"
	_GLenum_map[37814] = "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"
	_GLenum_map[37815] = "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"
	_GLenum_map[37816] = "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"
	_GLenum_map[37817] = "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"
	_GLenum_map[37818] = "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"
	_GLenum_map[37819] = "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"
	_GLenum_map[37820] = "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"
	_GLenum_map[37821] = "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"
	_GLenum_map[37824] = "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES"
	_GLenum_map[37825] = "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES"
	_GLenum_map[37826] = "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES"
	_GLenum_map[37827] = "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES"
	_GLenum_map[37828] = "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES"
	_GLenum_map[37829] = "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES"
	_GLenum_map[37830] = "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES"
	_GLenum_map[37831] = "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES"
	_GLenum_map[37832] = "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES"
	_GLenum_map[37833] = "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES"
	_GLenum_map[37840] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"
	_GLenum_map[37841] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"
	_GLenum_map[37842] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"
	_GLenum_map[37843] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"
	_GLenum_map[37844] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"
	_GLenum_map[37845] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"
	_GLenum_map[37846] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"
	_GLenum_map[37847] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"
	_GLenum_map[37848] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"
	_GLenum_map[37849] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"
	_GLenum_map[37850] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"
	_GLenum_map[37851] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"
	_GLenum_map[37852] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"
	_GLenum_map[37853] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"
	_GLenum_map[37856] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES"
	_GLenum_map[37857] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES"
	_GLenum_map[37858] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES"
	_GLenum_map[37859] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES"
	_GLenum_map[37860] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES"
	_GLenum_map[37861] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES"
	_GLenum_map[37862] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES"
	_GLenum_map[37863] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES"
	_GLenum_map[37864] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES"
	_GLenum_map[37865] = "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES"
	_GLenum_map[37872] = "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG"
	_GLenum_map[37873] = "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG"
	_GLenum_map[38128] = "GL_PERFQUERY_COUNTER_EVENT_INTEL"
	_GLenum_map[38129] = "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL"
	_GLenum_map[38130] = "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL"
	_GLenum_map[38131] = "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL"
	_GLenum_map[38132] = "GL_PERFQUERY_COUNTER_RAW_INTEL"
	_GLenum_map[38133] = "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL"
	_GLenum_map[38136] = "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL"
	_GLenum_map[38137] = "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL"
	_GLenum_map[38138] = "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL"
	_GLenum_map[38139] = "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL"
	_GLenum_map[38140] = "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL"
	_GLenum_map[38141] = "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL"
	_GLenum_map[38142] = "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL"
	_GLenum_map[38143] = "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL"
	_GLenum_map[38144] = "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL"
	_GLenum_map[38448] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"
	_GLenum_map[38449] = "GL_MAX_VIEWS_OVR"
	_GLenum_map[38450] = "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"
	_GLenum_map[38464] = "GL_GS_SHADER_BINARY_MTK"
	_GLenum_map[38465] = "GL_GS_PROGRAM_BINARY_MTK"
	_GLenum_map[103010] = "GL_RASTER_POSITION_UNCLIPPED_IBM"
	_GLenum_map[103050] = "GL_CULL_VERTEX_IBM"
	_GLenum_map[103060] = "GL_ALL_STATIC_DATA_IBM"
	_GLenum_map[103061] = "GL_STATIC_VERTEX_ARRAY_IBM"
	_GLenum_map[103070] = "GL_VERTEX_ARRAY_LIST_IBM"
	_GLenum_map[103071] = "GL_NORMAL_ARRAY_LIST_IBM"
	_GLenum_map[103072] = "GL_COLOR_ARRAY_LIST_IBM"
	_GLenum_map[103073] = "GL_INDEX_ARRAY_LIST_IBM"
	_GLenum_map[103074] = "GL_TEXTURE_COORD_ARRAY_LIST_IBM"
	_GLenum_map[103075] = "GL_EDGE_FLAG_ARRAY_LIST_IBM"
	_GLenum_map[103076] = "GL_FOG_COORDINATE_ARRAY_LIST_IBM"
	_GLenum_map[103077] = "GL_SECONDARY_COLOR_ARRAY_LIST_IBM"
	_GLenum_map[103080] = "GL_VERTEX_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103081] = "GL_NORMAL_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103082] = "GL_COLOR_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103083] = "GL_INDEX_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103084] = "GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103085] = "GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103086] = "GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[103087] = "GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM"
	_GLenum_map[107000] = "GL_PREFER_DOUBLEBUFFER_HINT_PGI"
	_GLenum_map[107005] = "GL_CONSERVE_MEMORY_HINT_PGI"
	_GLenum_map[107006] = "GL_RECLAIM_MEMORY_HINT_PGI"
	_GLenum_map[107010] = "GL_NATIVE_GRAPHICS_HANDLE_PGI"
	_GLenum_map[107011] = "GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI"
	_GLenum_map[107012] = "GL_NATIVE_GRAPHICS_END_HINT_PGI"
	_GLenum_map[107020] = "GL_ALWAYS_FAST_HINT_PGI"
	_GLenum_map[107021] = "GL_ALWAYS_SOFT_HINT_PGI"
	_GLenum_map[107022] = "GL_ALLOW_DRAW_OBJ_HINT_PGI"
	_GLenum_map[107023] = "GL_ALLOW_DRAW_WIN_HINT_PGI"
	_GLenum_map[107024] = "GL_ALLOW_DRAW_FRG_HINT_PGI"
	_GLenum_map[107025] = "GL_ALLOW_DRAW_MEM_HINT_PGI"
	_GLenum_map[107030] = "GL_STRICT_DEPTHFUNC_HINT_PGI"
	_GLenum_map[107031] = "GL_STRICT_LIGHTING_HINT_PGI"
	_GLenum_map[107032] = "GL_STRICT_SCISSOR_HINT_PGI"
	_GLenum_map[107033] = "GL_FULL_STIPPLE_HINT_PGI"
	_GLenum_map[107040] = "GL_CLIP_NEAR_HINT_PGI"
	_GLenum_map[107041] = "GL_CLIP_FAR_HINT_PGI"
	_GLenum_map[107042] = "GL_WIDE_LINE_HINT_PGI"
	_GLenum_map[107043] = "GL_BACK_NORMALS_HINT_PGI"
	_GLenum_map[107050] = "GL_VERTEX_DATA_HINT_PGI"
	_GLenum_map[107051] = "GL_VERTEX_CONSISTENT_HINT_PGI"
	_GLenum_map[107052] = "GL_MATERIAL_SIDE_HINT_PGI"
	_GLenum_map[107053] = "GL_MAX_VERTEX_HINT_PGI"
	_GLenum_map[4294967290] = "GL_SKIP_COMPONENTS1_NV"
	_GLenum_map[4294967291] = "GL_SKIP_COMPONENTS2_NV"
	_GLenum_map[4294967292] = "GL_SKIP_COMPONENTS3_NV"
	_GLenum_map[4294967293] = "GL_SKIP_COMPONENTS4_NV"
	_GLenum_map[4294967294] = "GL_NEXT_BUFFER_NV"
	_GLenum_map[4294967295] = "GL_INVALID_INDEX"

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32},
		Entries: []schema.Constant{
			{Name: "GL_TERMINATE_SEQUENCE_COMMAND_NV", Value: uint32(0)},
			{Name: "GL_CLOSE_PATH_NV", Value: uint32(0)},
			{Name: "GL_FALSE", Value: uint32(0)},
			{Name: "GL_ZERO", Value: uint32(0)},
			{Name: "GL_NONE", Value: uint32(0)},
			{Name: "GL_NONE_OES", Value: uint32(0)},
			{Name: "GL_NO_ERROR", Value: uint32(0)},
			{Name: "GL_LAYOUT_DEFAULT_INTEL", Value: uint32(0)},
			{Name: "GL_POINTS", Value: uint32(0)},
			{Name: "GL_TRUE", Value: uint32(1)},
			{Name: "GL_RESTART_SUN", Value: uint32(1)},
			{Name: "GL_VERSION_ES_CM_1_1", Value: uint32(1)},
			{Name: "GL_VERSION_ES_CL_1_1", Value: uint32(1)},
			{Name: "GL_VERSION_ES_CL_1_0", Value: uint32(1)},
			{Name: "GL_ONE", Value: uint32(1)},
			{Name: "GL_LAYOUT_LINEAR_INTEL", Value: uint32(1)},
			{Name: "GL_NOP_COMMAND_NV", Value: uint32(1)},
			{Name: "GL_LINES", Value: uint32(1)},
			{Name: "GL_REPLACE_MIDDLE_SUN", Value: uint32(2)},
			{Name: "GL_DRAW_ELEMENTS_COMMAND_NV", Value: uint32(2)},
			{Name: "GL_LAYOUT_LINEAR_CPU_CACHED_INTEL", Value: uint32(2)},
			{Name: "GL_LINE_LOOP", Value: uint32(2)},
			{Name: "GL_MOVE_TO_NV", Value: uint32(2)},
			{Name: "GL_RELATIVE_MOVE_TO_NV", Value: uint32(3)},
			{Name: "GL_LINE_STRIP", Value: uint32(3)},
			{Name: "GL_DRAW_ARRAYS_COMMAND_NV", Value: uint32(3)},
			{Name: "GL_REPLACE_OLDEST_SUN", Value: uint32(3)},
			{Name: "GL_LINE_TO_NV", Value: uint32(4)},
			{Name: "GL_DRAW_ELEMENTS_STRIP_COMMAND_NV", Value: uint32(4)},
			{Name: "GL_TRIANGLES", Value: uint32(4)},
			{Name: "GL_DRAW_ARRAYS_STRIP_COMMAND_NV", Value: uint32(5)},
			{Name: "GL_TRIANGLE_STRIP", Value: uint32(5)},
			{Name: "GL_RELATIVE_LINE_TO_NV", Value: uint32(5)},
			{Name: "GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV", Value: uint32(6)},
			{Name: "GL_HORIZONTAL_LINE_TO_NV", Value: uint32(6)},
			{Name: "GL_TRIANGLE_FAN", Value: uint32(6)},
			{Name: "GL_QUADS_EXT", Value: uint32(7)},
			{Name: "GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV", Value: uint32(7)},
			{Name: "GL_QUADS", Value: uint32(7)},
			{Name: "GL_RELATIVE_HORIZONTAL_LINE_TO_NV", Value: uint32(7)},
			{Name: "GL_QUADS_OES", Value: uint32(7)},
			{Name: "GL_VERTICAL_LINE_TO_NV", Value: uint32(8)},
			{Name: "GL_QUAD_STRIP", Value: uint32(8)},
			{Name: "GL_ELEMENT_ADDRESS_COMMAND_NV", Value: uint32(8)},
			{Name: "GL_POLYGON", Value: uint32(9)},
			{Name: "GL_RELATIVE_VERTICAL_LINE_TO_NV", Value: uint32(9)},
			{Name: "GL_ATTRIBUTE_ADDRESS_COMMAND_NV", Value: uint32(9)},
			{Name: "GL_LINES_ADJACENCY_EXT", Value: uint32(10)},
			{Name: "GL_LINES_ADJACENCY_ARB", Value: uint32(10)},
			{Name: "GL_LINES_ADJACENCY_OES", Value: uint32(10)},
			{Name: "GL_QUADRATIC_CURVE_TO_NV", Value: uint32(10)},
			{Name: "GL_UNIFORM_ADDRESS_COMMAND_NV", Value: uint32(10)},
			{Name: "GL_LINES_ADJACENCY", Value: uint32(10)},
			{Name: "GL_LINE_STRIP_ADJACENCY_EXT", Value: uint32(11)},
			{Name: "GL_LINE_STRIP_ADJACENCY", Value: uint32(11)},
			{Name: "GL_LINE_STRIP_ADJACENCY_ARB", Value: uint32(11)},
			{Name: "GL_LINE_STRIP_ADJACENCY_OES", Value: uint32(11)},
			{Name: "GL_BLEND_COLOR_COMMAND_NV", Value: uint32(11)},
			{Name: "GL_RELATIVE_QUADRATIC_CURVE_TO_NV", Value: uint32(11)},
			{Name: "GL_TRIANGLES_ADJACENCY_EXT", Value: uint32(12)},
			{Name: "GL_STENCIL_REF_COMMAND_NV", Value: uint32(12)},
			{Name: "GL_TRIANGLES_ADJACENCY_ARB", Value: uint32(12)},
			{Name: "GL_CUBIC_CURVE_TO_NV", Value: uint32(12)},
			{Name: "GL_TRIANGLES_ADJACENCY", Value: uint32(12)},
			{Name: "GL_TRIANGLES_ADJACENCY_OES", Value: uint32(12)},
			{Name: "GL_TRIANGLE_STRIP_ADJACENCY_EXT", Value: uint32(13)},
			{Name: "GL_TRIANGLE_STRIP_ADJACENCY_OES", Value: uint32(13)},
			{Name: "GL_LINE_WIDTH_COMMAND_NV", Value: uint32(13)},
			{Name: "GL_RELATIVE_CUBIC_CURVE_TO_NV", Value: uint32(13)},
			{Name: "GL_TRIANGLE_STRIP_ADJACENCY", Value: uint32(13)},
			{Name: "GL_TRIANGLE_STRIP_ADJACENCY_ARB", Value: uint32(13)},
			{Name: "GL_POLYGON_OFFSET_COMMAND_NV", Value: uint32(14)},
			{Name: "GL_PATCHES", Value: uint32(14)},
			{Name: "GL_PATCHES_OES", Value: uint32(14)},
			{Name: "GL_SMOOTH_QUADRATIC_CURVE_TO_NV", Value: uint32(14)},
			{Name: "GL_PATCHES_EXT", Value: uint32(14)},
			{Name: "GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV", Value: uint32(15)},
			{Name: "GL_ALPHA_REF_COMMAND_NV", Value: uint32(15)},
			{Name: "GL_VIEWPORT_COMMAND_NV", Value: uint32(16)},
			{Name: "GL_SMOOTH_CUBIC_CURVE_TO_NV", Value: uint32(16)},
			{Name: "GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV", Value: uint32(17)},
			{Name: "GL_SCISSOR_COMMAND_NV", Value: uint32(17)},
			{Name: "GL_SMALL_CCW_ARC_TO_NV", Value: uint32(18)},
			{Name: "GL_FRONT_FACE_COMMAND_NV", Value: uint32(18)},
			{Name: "GL_RELATIVE_SMALL_CCW_ARC_TO_NV", Value: uint32(19)},
			{Name: "GL_SMALL_CW_ARC_TO_NV", Value: uint32(20)},
			{Name: "GL_RELATIVE_SMALL_CW_ARC_TO_NV", Value: uint32(21)},
			{Name: "GL_LARGE_CCW_ARC_TO_NV", Value: uint32(22)},
			{Name: "GL_RELATIVE_LARGE_CCW_ARC_TO_NV", Value: uint32(23)},
			{Name: "GL_LARGE_CW_ARC_TO_NV", Value: uint32(24)},
			{Name: "GL_RELATIVE_LARGE_CW_ARC_TO_NV", Value: uint32(25)},
			{Name: "GL_CONIC_CURVE_TO_NV", Value: uint32(26)},
			{Name: "GL_RELATIVE_CONIC_CURVE_TO_NV", Value: uint32(27)},
			{Name: "GL_SHARED_EDGE_NV", Value: uint32(192)},
			{Name: "GL_ROUNDED_RECT_NV", Value: uint32(232)},
			{Name: "GL_RELATIVE_ROUNDED_RECT_NV", Value: uint32(233)},
			{Name: "GL_ROUNDED_RECT2_NV", Value: uint32(234)},
			{Name: "GL_RELATIVE_ROUNDED_RECT2_NV", Value: uint32(235)},
			{Name: "GL_ROUNDED_RECT4_NV", Value: uint32(236)},
			{Name: "GL_RELATIVE_ROUNDED_RECT4_NV", Value: uint32(237)},
			{Name: "GL_ROUNDED_RECT8_NV", Value: uint32(238)},
			{Name: "GL_RELATIVE_ROUNDED_RECT8_NV", Value: uint32(239)},
			{Name: "GL_RESTART_PATH_NV", Value: uint32(240)},
			{Name: "GL_DUP_FIRST_CUBIC_CURVE_TO_NV", Value: uint32(242)},
			{Name: "GL_DUP_LAST_CUBIC_CURVE_TO_NV", Value: uint32(244)},
			{Name: "GL_RECT_NV", Value: uint32(246)},
			{Name: "GL_RELATIVE_RECT_NV", Value: uint32(247)},
			{Name: "GL_CIRCULAR_CCW_ARC_TO_NV", Value: uint32(248)},
			{Name: "GL_CIRCULAR_CW_ARC_TO_NV", Value: uint32(250)},
			{Name: "GL_CIRCULAR_TANGENT_ARC_TO_NV", Value: uint32(252)},
			{Name: "GL_ARC_TO_NV", Value: uint32(254)},
			{Name: "GL_RELATIVE_ARC_TO_NV", Value: uint32(255)},
			{Name: "GL_ACCUM", Value: uint32(256)},
			{Name: "GL_LOAD", Value: uint32(257)},
			{Name: "GL_RETURN", Value: uint32(258)},
			{Name: "GL_MULT", Value: uint32(259)},
			{Name: "GL_ADD", Value: uint32(260)},
			{Name: "GL_NEVER", Value: uint32(512)},
			{Name: "GL_LESS", Value: uint32(513)},
			{Name: "GL_EQUAL", Value: uint32(514)},
			{Name: "GL_LEQUAL", Value: uint32(515)},
			{Name: "GL_GREATER", Value: uint32(516)},
			{Name: "GL_NOTEQUAL", Value: uint32(517)},
			{Name: "GL_GEQUAL", Value: uint32(518)},
			{Name: "GL_ALWAYS", Value: uint32(519)},
			{Name: "GL_SRC_COLOR", Value: uint32(768)},
			{Name: "GL_ONE_MINUS_SRC_COLOR", Value: uint32(769)},
			{Name: "GL_SRC_ALPHA", Value: uint32(770)},
			{Name: "GL_ONE_MINUS_SRC_ALPHA", Value: uint32(771)},
			{Name: "GL_DST_ALPHA", Value: uint32(772)},
			{Name: "GL_ONE_MINUS_DST_ALPHA", Value: uint32(773)},
			{Name: "GL_DST_COLOR", Value: uint32(774)},
			{Name: "GL_ONE_MINUS_DST_COLOR", Value: uint32(775)},
			{Name: "GL_SRC_ALPHA_SATURATE", Value: uint32(776)},
			{Name: "GL_FRONT_LEFT", Value: uint32(1024)},
			{Name: "GL_FRONT_RIGHT", Value: uint32(1025)},
			{Name: "GL_BACK_LEFT", Value: uint32(1026)},
			{Name: "GL_BACK_RIGHT", Value: uint32(1027)},
			{Name: "GL_FRONT", Value: uint32(1028)},
			{Name: "GL_BACK", Value: uint32(1029)},
			{Name: "GL_LEFT", Value: uint32(1030)},
			{Name: "GL_RIGHT", Value: uint32(1031)},
			{Name: "GL_FRONT_AND_BACK", Value: uint32(1032)},
			{Name: "GL_AUX0", Value: uint32(1033)},
			{Name: "GL_AUX1", Value: uint32(1034)},
			{Name: "GL_AUX2", Value: uint32(1035)},
			{Name: "GL_AUX3", Value: uint32(1036)},
			{Name: "GL_INVALID_ENUM", Value: uint32(1280)},
			{Name: "GL_INVALID_VALUE", Value: uint32(1281)},
			{Name: "GL_INVALID_OPERATION", Value: uint32(1282)},
			{Name: "GL_STACK_OVERFLOW", Value: uint32(1283)},
			{Name: "GL_STACK_OVERFLOW_KHR", Value: uint32(1283)},
			{Name: "GL_STACK_UNDERFLOW", Value: uint32(1284)},
			{Name: "GL_STACK_UNDERFLOW_KHR", Value: uint32(1284)},
			{Name: "GL_OUT_OF_MEMORY", Value: uint32(1285)},
			{Name: "GL_INVALID_FRAMEBUFFER_OPERATION", Value: uint32(1286)},
			{Name: "GL_INVALID_FRAMEBUFFER_OPERATION_OES", Value: uint32(1286)},
			{Name: "GL_INVALID_FRAMEBUFFER_OPERATION_EXT", Value: uint32(1286)},
			{Name: "GL_CONTEXT_LOST_KHR", Value: uint32(1287)},
			{Name: "GL_CONTEXT_LOST", Value: uint32(1287)},
			{Name: "GL_2D", Value: uint32(1536)},
			{Name: "GL_3D", Value: uint32(1537)},
			{Name: "GL_3D_COLOR", Value: uint32(1538)},
			{Name: "GL_3D_COLOR_TEXTURE", Value: uint32(1539)},
			{Name: "GL_4D_COLOR_TEXTURE", Value: uint32(1540)},
			{Name: "GL_PASS_THROUGH_TOKEN", Value: uint32(1792)},
			{Name: "GL_POINT_TOKEN", Value: uint32(1793)},
			{Name: "GL_LINE_TOKEN", Value: uint32(1794)},
			{Name: "GL_POLYGON_TOKEN", Value: uint32(1795)},
			{Name: "GL_BITMAP_TOKEN", Value: uint32(1796)},
			{Name: "GL_DRAW_PIXEL_TOKEN", Value: uint32(1797)},
			{Name: "GL_COPY_PIXEL_TOKEN", Value: uint32(1798)},
			{Name: "GL_LINE_RESET_TOKEN", Value: uint32(1799)},
			{Name: "GL_EXP", Value: uint32(2048)},
			{Name: "GL_EXP2", Value: uint32(2049)},
			{Name: "GL_CW", Value: uint32(2304)},
			{Name: "GL_CCW", Value: uint32(2305)},
			{Name: "GL_COEFF", Value: uint32(2560)},
			{Name: "GL_ORDER", Value: uint32(2561)},
			{Name: "GL_DOMAIN", Value: uint32(2562)},
			{Name: "GL_CURRENT_COLOR", Value: uint32(2816)},
			{Name: "GL_CURRENT_INDEX", Value: uint32(2817)},
			{Name: "GL_CURRENT_NORMAL", Value: uint32(2818)},
			{Name: "GL_CURRENT_TEXTURE_COORDS", Value: uint32(2819)},
			{Name: "GL_CURRENT_RASTER_COLOR", Value: uint32(2820)},
			{Name: "GL_CURRENT_RASTER_INDEX", Value: uint32(2821)},
			{Name: "GL_CURRENT_RASTER_TEXTURE_COORDS", Value: uint32(2822)},
			{Name: "GL_CURRENT_RASTER_POSITION", Value: uint32(2823)},
			{Name: "GL_CURRENT_RASTER_POSITION_VALID", Value: uint32(2824)},
			{Name: "GL_CURRENT_RASTER_DISTANCE", Value: uint32(2825)},
			{Name: "GL_POINT_SMOOTH", Value: uint32(2832)},
			{Name: "GL_POINT_SIZE", Value: uint32(2833)},
			{Name: "GL_SMOOTH_POINT_SIZE_RANGE", Value: uint32(2834)},
			{Name: "GL_POINT_SIZE_RANGE", Value: uint32(2834)},
			{Name: "GL_SMOOTH_POINT_SIZE_GRANULARITY", Value: uint32(2835)},
			{Name: "GL_POINT_SIZE_GRANULARITY", Value: uint32(2835)},
			{Name: "GL_LINE_SMOOTH", Value: uint32(2848)},
			{Name: "GL_LINE_WIDTH", Value: uint32(2849)},
			{Name: "GL_SMOOTH_LINE_WIDTH_RANGE", Value: uint32(2850)},
			{Name: "GL_LINE_WIDTH_RANGE", Value: uint32(2850)},
			{Name: "GL_SMOOTH_LINE_WIDTH_GRANULARITY", Value: uint32(2851)},
			{Name: "GL_LINE_WIDTH_GRANULARITY", Value: uint32(2851)},
			{Name: "GL_LINE_STIPPLE", Value: uint32(2852)},
			{Name: "GL_LINE_STIPPLE_PATTERN", Value: uint32(2853)},
			{Name: "GL_LINE_STIPPLE_REPEAT", Value: uint32(2854)},
			{Name: "GL_LIST_MODE", Value: uint32(2864)},
			{Name: "GL_MAX_LIST_NESTING", Value: uint32(2865)},
			{Name: "GL_LIST_BASE", Value: uint32(2866)},
			{Name: "GL_LIST_INDEX", Value: uint32(2867)},
			{Name: "GL_POLYGON_MODE", Value: uint32(2880)},
			{Name: "GL_POLYGON_MODE_NV", Value: uint32(2880)},
			{Name: "GL_POLYGON_SMOOTH", Value: uint32(2881)},
			{Name: "GL_POLYGON_STIPPLE", Value: uint32(2882)},
			{Name: "GL_EDGE_FLAG", Value: uint32(2883)},
			{Name: "GL_CULL_FACE", Value: uint32(2884)},
			{Name: "GL_CULL_FACE_MODE", Value: uint32(2885)},
			{Name: "GL_FRONT_FACE", Value: uint32(2886)},
			{Name: "GL_LIGHTING", Value: uint32(2896)},
			{Name: "GL_LIGHT_MODEL_LOCAL_VIEWER", Value: uint32(2897)},
			{Name: "GL_LIGHT_MODEL_TWO_SIDE", Value: uint32(2898)},
			{Name: "GL_LIGHT_MODEL_AMBIENT", Value: uint32(2899)},
			{Name: "GL_SHADE_MODEL", Value: uint32(2900)},
			{Name: "GL_COLOR_MATERIAL_FACE", Value: uint32(2901)},
			{Name: "GL_COLOR_MATERIAL_PARAMETER", Value: uint32(2902)},
			{Name: "GL_COLOR_MATERIAL", Value: uint32(2903)},
			{Name: "GL_FOG", Value: uint32(2912)},
			{Name: "GL_FOG_INDEX", Value: uint32(2913)},
			{Name: "GL_FOG_DENSITY", Value: uint32(2914)},
			{Name: "GL_FOG_START", Value: uint32(2915)},
			{Name: "GL_FOG_END", Value: uint32(2916)},
			{Name: "GL_FOG_MODE", Value: uint32(2917)},
			{Name: "GL_FOG_COLOR", Value: uint32(2918)},
			{Name: "GL_DEPTH_RANGE", Value: uint32(2928)},
			{Name: "GL_DEPTH_TEST", Value: uint32(2929)},
			{Name: "GL_DEPTH_WRITEMASK", Value: uint32(2930)},
			{Name: "GL_DEPTH_CLEAR_VALUE", Value: uint32(2931)},
			{Name: "GL_DEPTH_FUNC", Value: uint32(2932)},
			{Name: "GL_ACCUM_CLEAR_VALUE", Value: uint32(2944)},
			{Name: "GL_STENCIL_TEST", Value: uint32(2960)},
			{Name: "GL_STENCIL_CLEAR_VALUE", Value: uint32(2961)},
			{Name: "GL_STENCIL_FUNC", Value: uint32(2962)},
			{Name: "GL_STENCIL_VALUE_MASK", Value: uint32(2963)},
			{Name: "GL_STENCIL_FAIL", Value: uint32(2964)},
			{Name: "GL_STENCIL_PASS_DEPTH_FAIL", Value: uint32(2965)},
			{Name: "GL_STENCIL_PASS_DEPTH_PASS", Value: uint32(2966)},
			{Name: "GL_STENCIL_REF", Value: uint32(2967)},
			{Name: "GL_STENCIL_WRITEMASK", Value: uint32(2968)},
			{Name: "GL_MATRIX_MODE", Value: uint32(2976)},
			{Name: "GL_NORMALIZE", Value: uint32(2977)},
			{Name: "GL_VIEWPORT", Value: uint32(2978)},
			{Name: "GL_MODELVIEW0_STACK_DEPTH_EXT", Value: uint32(2979)},
			{Name: "GL_PATH_MODELVIEW_STACK_DEPTH_NV", Value: uint32(2979)},
			{Name: "GL_MODELVIEW_STACK_DEPTH", Value: uint32(2979)},
			{Name: "GL_PROJECTION_STACK_DEPTH", Value: uint32(2980)},
			{Name: "GL_PATH_PROJECTION_STACK_DEPTH_NV", Value: uint32(2980)},
			{Name: "GL_TEXTURE_STACK_DEPTH", Value: uint32(2981)},
			{Name: "GL_PATH_MODELVIEW_MATRIX_NV", Value: uint32(2982)},
			{Name: "GL_MODELVIEW_MATRIX", Value: uint32(2982)},
			{Name: "GL_MODELVIEW0_MATRIX_EXT", Value: uint32(2982)},
			{Name: "GL_PATH_PROJECTION_MATRIX_NV", Value: uint32(2983)},
			{Name: "GL_PROJECTION_MATRIX", Value: uint32(2983)},
			{Name: "GL_TEXTURE_MATRIX", Value: uint32(2984)},
			{Name: "GL_ATTRIB_STACK_DEPTH", Value: uint32(2992)},
			{Name: "GL_CLIENT_ATTRIB_STACK_DEPTH", Value: uint32(2993)},
			{Name: "GL_ALPHA_TEST_QCOM", Value: uint32(3008)},
			{Name: "GL_ALPHA_TEST", Value: uint32(3008)},
			{Name: "GL_ALPHA_TEST_FUNC_QCOM", Value: uint32(3009)},
			{Name: "GL_ALPHA_TEST_FUNC", Value: uint32(3009)},
			{Name: "GL_ALPHA_TEST_REF_QCOM", Value: uint32(3010)},
			{Name: "GL_ALPHA_TEST_REF", Value: uint32(3010)},
			{Name: "GL_DITHER", Value: uint32(3024)},
			{Name: "GL_BLEND_DST", Value: uint32(3040)},
			{Name: "GL_BLEND_SRC", Value: uint32(3041)},
			{Name: "GL_BLEND", Value: uint32(3042)},
			{Name: "GL_LOGIC_OP_MODE", Value: uint32(3056)},
			{Name: "GL_LOGIC_OP", Value: uint32(3057)},
			{Name: "GL_INDEX_LOGIC_OP", Value: uint32(3057)},
			{Name: "GL_COLOR_LOGIC_OP", Value: uint32(3058)},
			{Name: "GL_AUX_BUFFERS", Value: uint32(3072)},
			{Name: "GL_DRAW_BUFFER_EXT", Value: uint32(3073)},
			{Name: "GL_DRAW_BUFFER", Value: uint32(3073)},
			{Name: "GL_READ_BUFFER", Value: uint32(3074)},
			{Name: "GL_READ_BUFFER_NV", Value: uint32(3074)},
			{Name: "GL_READ_BUFFER_EXT", Value: uint32(3074)},
			{Name: "GL_SCISSOR_BOX", Value: uint32(3088)},
			{Name: "GL_SCISSOR_TEST", Value: uint32(3089)},
			{Name: "GL_INDEX_CLEAR_VALUE", Value: uint32(3104)},
			{Name: "GL_INDEX_WRITEMASK", Value: uint32(3105)},
			{Name: "GL_COLOR_CLEAR_VALUE", Value: uint32(3106)},
			{Name: "GL_COLOR_WRITEMASK", Value: uint32(3107)},
			{Name: "GL_INDEX_MODE", Value: uint32(3120)},
			{Name: "GL_RGBA_MODE", Value: uint32(3121)},
			{Name: "GL_DOUBLEBUFFER", Value: uint32(3122)},
			{Name: "GL_STEREO", Value: uint32(3123)},
			{Name: "GL_RENDER_MODE", Value: uint32(3136)},
			{Name: "GL_PERSPECTIVE_CORRECTION_HINT", Value: uint32(3152)},
			{Name: "GL_POINT_SMOOTH_HINT", Value: uint32(3153)},
			{Name: "GL_LINE_SMOOTH_HINT", Value: uint32(3154)},
			{Name: "GL_POLYGON_SMOOTH_HINT", Value: uint32(3155)},
			{Name: "GL_FOG_HINT", Value: uint32(3156)},
			{Name: "GL_TEXTURE_GEN_S", Value: uint32(3168)},
			{Name: "GL_TEXTURE_GEN_T", Value: uint32(3169)},
			{Name: "GL_TEXTURE_GEN_R", Value: uint32(3170)},
			{Name: "GL_TEXTURE_GEN_Q", Value: uint32(3171)},
			{Name: "GL_PIXEL_MAP_I_TO_I", Value: uint32(3184)},
			{Name: "GL_PIXEL_MAP_S_TO_S", Value: uint32(3185)},
			{Name: "GL_PIXEL_MAP_I_TO_R", Value: uint32(3186)},
			{Name: "GL_PIXEL_MAP_I_TO_G", Value: uint32(3187)},
			{Name: "GL_PIXEL_MAP_I_TO_B", Value: uint32(3188)},
			{Name: "GL_PIXEL_MAP_I_TO_A", Value: uint32(3189)},
			{Name: "GL_PIXEL_MAP_R_TO_R", Value: uint32(3190)},
			{Name: "GL_PIXEL_MAP_G_TO_G", Value: uint32(3191)},
			{Name: "GL_PIXEL_MAP_B_TO_B", Value: uint32(3192)},
			{Name: "GL_PIXEL_MAP_A_TO_A", Value: uint32(3193)},
			{Name: "GL_PIXEL_MAP_I_TO_I_SIZE", Value: uint32(3248)},
			{Name: "GL_PIXEL_MAP_S_TO_S_SIZE", Value: uint32(3249)},
			{Name: "GL_PIXEL_MAP_I_TO_R_SIZE", Value: uint32(3250)},
			{Name: "GL_PIXEL_MAP_I_TO_G_SIZE", Value: uint32(3251)},
			{Name: "GL_PIXEL_MAP_I_TO_B_SIZE", Value: uint32(3252)},
			{Name: "GL_PIXEL_MAP_I_TO_A_SIZE", Value: uint32(3253)},
			{Name: "GL_PIXEL_MAP_R_TO_R_SIZE", Value: uint32(3254)},
			{Name: "GL_PIXEL_MAP_G_TO_G_SIZE", Value: uint32(3255)},
			{Name: "GL_PIXEL_MAP_B_TO_B_SIZE", Value: uint32(3256)},
			{Name: "GL_PIXEL_MAP_A_TO_A_SIZE", Value: uint32(3257)},
			{Name: "GL_UNPACK_SWAP_BYTES", Value: uint32(3312)},
			{Name: "GL_UNPACK_LSB_FIRST", Value: uint32(3313)},
			{Name: "GL_UNPACK_ROW_LENGTH", Value: uint32(3314)},
			{Name: "GL_UNPACK_ROW_LENGTH_EXT", Value: uint32(3314)},
			{Name: "GL_UNPACK_SKIP_ROWS", Value: uint32(3315)},
			{Name: "GL_UNPACK_SKIP_ROWS_EXT", Value: uint32(3315)},
			{Name: "GL_UNPACK_SKIP_PIXELS", Value: uint32(3316)},
			{Name: "GL_UNPACK_SKIP_PIXELS_EXT", Value: uint32(3316)},
			{Name: "GL_UNPACK_ALIGNMENT", Value: uint32(3317)},
			{Name: "GL_PACK_SWAP_BYTES", Value: uint32(3328)},
			{Name: "GL_PACK_LSB_FIRST", Value: uint32(3329)},
			{Name: "GL_PACK_ROW_LENGTH", Value: uint32(3330)},
			{Name: "GL_PACK_SKIP_ROWS", Value: uint32(3331)},
			{Name: "GL_PACK_SKIP_PIXELS", Value: uint32(3332)},
			{Name: "GL_PACK_ALIGNMENT", Value: uint32(3333)},
			{Name: "GL_MAP_COLOR", Value: uint32(3344)},
			{Name: "GL_MAP_STENCIL", Value: uint32(3345)},
			{Name: "GL_INDEX_SHIFT", Value: uint32(3346)},
			{Name: "GL_INDEX_OFFSET", Value: uint32(3347)},
			{Name: "GL_RED_SCALE", Value: uint32(3348)},
			{Name: "GL_RED_BIAS", Value: uint32(3349)},
			{Name: "GL_ZOOM_X", Value: uint32(3350)},
			{Name: "GL_ZOOM_Y", Value: uint32(3351)},
			{Name: "GL_GREEN_SCALE", Value: uint32(3352)},
			{Name: "GL_GREEN_BIAS", Value: uint32(3353)},
			{Name: "GL_BLUE_SCALE", Value: uint32(3354)},
			{Name: "GL_BLUE_BIAS", Value: uint32(3355)},
			{Name: "GL_ALPHA_SCALE", Value: uint32(3356)},
			{Name: "GL_ALPHA_BIAS", Value: uint32(3357)},
			{Name: "GL_DEPTH_SCALE", Value: uint32(3358)},
			{Name: "GL_DEPTH_BIAS", Value: uint32(3359)},
			{Name: "GL_MAX_EVAL_ORDER", Value: uint32(3376)},
			{Name: "GL_MAX_LIGHTS", Value: uint32(3377)},
			{Name: "GL_MAX_CLIP_DISTANCES_APPLE", Value: uint32(3378)},
			{Name: "GL_MAX_CLIP_PLANES", Value: uint32(3378)},
			{Name: "GL_MAX_CLIP_DISTANCES", Value: uint32(3378)},
			{Name: "GL_MAX_CLIP_PLANES_IMG", Value: uint32(3378)},
			{Name: "GL_MAX_TEXTURE_SIZE", Value: uint32(3379)},
			{Name: "GL_MAX_PIXEL_MAP_TABLE", Value: uint32(3380)},
			{Name: "GL_MAX_ATTRIB_STACK_DEPTH", Value: uint32(3381)},
			{Name: "GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV", Value: uint32(3382)},
			{Name: "GL_MAX_MODELVIEW_STACK_DEPTH", Value: uint32(3382)},
			{Name: "GL_MAX_NAME_STACK_DEPTH", Value: uint32(3383)},
			{Name: "GL_MAX_PROJECTION_STACK_DEPTH", Value: uint32(3384)},
			{Name: "GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV", Value: uint32(3384)},
			{Name: "GL_MAX_TEXTURE_STACK_DEPTH", Value: uint32(3385)},
			{Name: "GL_MAX_VIEWPORT_DIMS", Value: uint32(3386)},
			{Name: "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH", Value: uint32(3387)},
			{Name: "GL_SUBPIXEL_BITS", Value: uint32(3408)},
			{Name: "GL_INDEX_BITS", Value: uint32(3409)},
			{Name: "GL_RED_BITS", Value: uint32(3410)},
			{Name: "GL_GREEN_BITS", Value: uint32(3411)},
			{Name: "GL_BLUE_BITS", Value: uint32(3412)},
			{Name: "GL_ALPHA_BITS", Value: uint32(3413)},
			{Name: "GL_DEPTH_BITS", Value: uint32(3414)},
			{Name: "GL_STENCIL_BITS", Value: uint32(3415)},
			{Name: "GL_ACCUM_RED_BITS", Value: uint32(3416)},
			{Name: "GL_ACCUM_GREEN_BITS", Value: uint32(3417)},
			{Name: "GL_ACCUM_BLUE_BITS", Value: uint32(3418)},
			{Name: "GL_ACCUM_ALPHA_BITS", Value: uint32(3419)},
			{Name: "GL_NAME_STACK_DEPTH", Value: uint32(3440)},
			{Name: "GL_AUTO_NORMAL", Value: uint32(3456)},
			{Name: "GL_MAP1_COLOR_4", Value: uint32(3472)},
			{Name: "GL_MAP1_INDEX", Value: uint32(3473)},
			{Name: "GL_MAP1_NORMAL", Value: uint32(3474)},
			{Name: "GL_MAP1_TEXTURE_COORD_1", Value: uint32(3475)},
			{Name: "GL_MAP1_TEXTURE_COORD_2", Value: uint32(3476)},
			{Name: "GL_MAP1_TEXTURE_COORD_3", Value: uint32(3477)},
			{Name: "GL_MAP1_TEXTURE_COORD_4", Value: uint32(3478)},
			{Name: "GL_MAP1_VERTEX_3", Value: uint32(3479)},
			{Name: "GL_MAP1_VERTEX_4", Value: uint32(3480)},
			{Name: "GL_MAP2_COLOR_4", Value: uint32(3504)},
			{Name: "GL_MAP2_INDEX", Value: uint32(3505)},
			{Name: "GL_MAP2_NORMAL", Value: uint32(3506)},
			{Name: "GL_MAP2_TEXTURE_COORD_1", Value: uint32(3507)},
			{Name: "GL_MAP2_TEXTURE_COORD_2", Value: uint32(3508)},
			{Name: "GL_MAP2_TEXTURE_COORD_3", Value: uint32(3509)},
			{Name: "GL_MAP2_TEXTURE_COORD_4", Value: uint32(3510)},
			{Name: "GL_MAP2_VERTEX_3", Value: uint32(3511)},
			{Name: "GL_MAP2_VERTEX_4", Value: uint32(3512)},
			{Name: "GL_MAP1_GRID_DOMAIN", Value: uint32(3536)},
			{Name: "GL_MAP1_GRID_SEGMENTS", Value: uint32(3537)},
			{Name: "GL_MAP2_GRID_DOMAIN", Value: uint32(3538)},
			{Name: "GL_MAP2_GRID_SEGMENTS", Value: uint32(3539)},
			{Name: "GL_TEXTURE_1D", Value: uint32(3552)},
			{Name: "GL_TEXTURE_2D", Value: uint32(3553)},
			{Name: "GL_FEEDBACK_BUFFER_POINTER", Value: uint32(3568)},
			{Name: "GL_FEEDBACK_BUFFER_SIZE", Value: uint32(3569)},
			{Name: "GL_FEEDBACK_BUFFER_TYPE", Value: uint32(3570)},
			{Name: "GL_SELECTION_BUFFER_POINTER", Value: uint32(3571)},
			{Name: "GL_SELECTION_BUFFER_SIZE", Value: uint32(3572)},
			{Name: "GL_TEXTURE_WIDTH", Value: uint32(4096)},
			{Name: "GL_TEXTURE_HEIGHT", Value: uint32(4097)},
			{Name: "GL_TEXTURE_INTERNAL_FORMAT", Value: uint32(4099)},
			{Name: "GL_TEXTURE_COMPONENTS", Value: uint32(4099)},
			{Name: "GL_TEXTURE_BORDER_COLOR_EXT", Value: uint32(4100)},
			{Name: "GL_TEXTURE_BORDER_COLOR_NV", Value: uint32(4100)},
			{Name: "GL_TEXTURE_BORDER_COLOR_OES", Value: uint32(4100)},
			{Name: "GL_TEXTURE_BORDER_COLOR", Value: uint32(4100)},
			{Name: "GL_TEXTURE_BORDER", Value: uint32(4101)},
			{Name: "GL_TEXTURE_TARGET", Value: uint32(4102)},
			{Name: "GL_DONT_CARE", Value: uint32(4352)},
			{Name: "GL_FASTEST", Value: uint32(4353)},
			{Name: "GL_NICEST", Value: uint32(4354)},
			{Name: "GL_AMBIENT", Value: uint32(4608)},
			{Name: "GL_DIFFUSE", Value: uint32(4609)},
			{Name: "GL_SPECULAR", Value: uint32(4610)},
			{Name: "GL_POSITION", Value: uint32(4611)},
			{Name: "GL_SPOT_DIRECTION", Value: uint32(4612)},
			{Name: "GL_SPOT_EXPONENT", Value: uint32(4613)},
			{Name: "GL_SPOT_CUTOFF", Value: uint32(4614)},
			{Name: "GL_CONSTANT_ATTENUATION", Value: uint32(4615)},
			{Name: "GL_LINEAR_ATTENUATION", Value: uint32(4616)},
			{Name: "GL_QUADRATIC_ATTENUATION", Value: uint32(4617)},
			{Name: "GL_COMPILE", Value: uint32(4864)},
			{Name: "GL_COMPILE_AND_EXECUTE", Value: uint32(4865)},
			{Name: "GL_BYTE", Value: uint32(5120)},
			{Name: "GL_UNSIGNED_BYTE", Value: uint32(5121)},
			{Name: "GL_SHORT", Value: uint32(5122)},
			{Name: "GL_UNSIGNED_SHORT", Value: uint32(5123)},
			{Name: "GL_INT", Value: uint32(5124)},
			{Name: "GL_UNSIGNED_INT", Value: uint32(5125)},
			{Name: "GL_FLOAT", Value: uint32(5126)},
			{Name: "GL_2_BYTES", Value: uint32(5127)},
			{Name: "GL_2_BYTES_NV", Value: uint32(5127)},
			{Name: "GL_3_BYTES", Value: uint32(5128)},
			{Name: "GL_3_BYTES_NV", Value: uint32(5128)},
			{Name: "GL_4_BYTES_NV", Value: uint32(5129)},
			{Name: "GL_4_BYTES", Value: uint32(5129)},
			{Name: "GL_DOUBLE_EXT", Value: uint32(5130)},
			{Name: "GL_DOUBLE", Value: uint32(5130)},
			{Name: "GL_HALF_FLOAT_ARB", Value: uint32(5131)},
			{Name: "GL_HALF_FLOAT", Value: uint32(5131)},
			{Name: "GL_HALF_APPLE", Value: uint32(5131)},
			{Name: "GL_HALF_FLOAT_NV", Value: uint32(5131)},
			{Name: "GL_FIXED_OES", Value: uint32(5132)},
			{Name: "GL_FIXED", Value: uint32(5132)},
			{Name: "GL_INT64_NV", Value: uint32(5134)},
			{Name: "GL_UNSIGNED_INT64_ARB", Value: uint32(5135)},
			{Name: "GL_UNSIGNED_INT64_NV", Value: uint32(5135)},
			{Name: "GL_CLEAR", Value: uint32(5376)},
			{Name: "GL_AND", Value: uint32(5377)},
			{Name: "GL_AND_REVERSE", Value: uint32(5378)},
			{Name: "GL_COPY", Value: uint32(5379)},
			{Name: "GL_AND_INVERTED", Value: uint32(5380)},
			{Name: "GL_NOOP", Value: uint32(5381)},
			{Name: "GL_XOR_NV", Value: uint32(5382)},
			{Name: "GL_XOR", Value: uint32(5382)},
			{Name: "GL_OR", Value: uint32(5383)},
			{Name: "GL_NOR", Value: uint32(5384)},
			{Name: "GL_EQUIV", Value: uint32(5385)},
			{Name: "GL_INVERT", Value: uint32(5386)},
			{Name: "GL_OR_REVERSE", Value: uint32(5387)},
			{Name: "GL_COPY_INVERTED", Value: uint32(5388)},
			{Name: "GL_OR_INVERTED", Value: uint32(5389)},
			{Name: "GL_NAND", Value: uint32(5390)},
			{Name: "GL_SET", Value: uint32(5391)},
			{Name: "GL_EMISSION", Value: uint32(5632)},
			{Name: "GL_SHININESS", Value: uint32(5633)},
			{Name: "GL_AMBIENT_AND_DIFFUSE", Value: uint32(5634)},
			{Name: "GL_COLOR_INDEXES", Value: uint32(5635)},
			{Name: "GL_MODELVIEW", Value: uint32(5888)},
			{Name: "GL_MODELVIEW0_EXT", Value: uint32(5888)},
			{Name: "GL_MODELVIEW0_ARB", Value: uint32(5888)},
			{Name: "GL_PATH_MODELVIEW_NV", Value: uint32(5888)},
			{Name: "GL_PATH_PROJECTION_NV", Value: uint32(5889)},
			{Name: "GL_PROJECTION", Value: uint32(5889)},
			{Name: "GL_TEXTURE", Value: uint32(5890)},
			{Name: "GL_COLOR", Value: uint32(6144)},
			{Name: "GL_COLOR_EXT", Value: uint32(6144)},
			{Name: "GL_DEPTH_EXT", Value: uint32(6145)},
			{Name: "GL_DEPTH", Value: uint32(6145)},
			{Name: "GL_STENCIL_EXT", Value: uint32(6146)},
			{Name: "GL_STENCIL", Value: uint32(6146)},
			{Name: "GL_COLOR_INDEX", Value: uint32(6400)},
			{Name: "GL_STENCIL_INDEX_OES", Value: uint32(6401)},
			{Name: "GL_STENCIL_INDEX", Value: uint32(6401)},
			{Name: "GL_DEPTH_COMPONENT", Value: uint32(6402)},
			{Name: "GL_RED", Value: uint32(6403)},
			{Name: "GL_RED_NV", Value: uint32(6403)},
			{Name: "GL_RED_EXT", Value: uint32(6403)},
			{Name: "GL_GREEN_NV", Value: uint32(6404)},
			{Name: "GL_GREEN", Value: uint32(6404)},
			{Name: "GL_BLUE", Value: uint32(6405)},
			{Name: "GL_BLUE_NV", Value: uint32(6405)},
			{Name: "GL_ALPHA", Value: uint32(6406)},
			{Name: "GL_RGB", Value: uint32(6407)},
			{Name: "GL_RGBA", Value: uint32(6408)},
			{Name: "GL_LUMINANCE", Value: uint32(6409)},
			{Name: "GL_LUMINANCE_ALPHA", Value: uint32(6410)},
			{Name: "GL_BITMAP", Value: uint32(6656)},
			{Name: "GL_POINT_NV", Value: uint32(6912)},
			{Name: "GL_POINT", Value: uint32(6912)},
			{Name: "GL_LINE_NV", Value: uint32(6913)},
			{Name: "GL_LINE", Value: uint32(6913)},
			{Name: "GL_FILL", Value: uint32(6914)},
			{Name: "GL_FILL_NV", Value: uint32(6914)},
			{Name: "GL_RENDER", Value: uint32(7168)},
			{Name: "GL_FEEDBACK", Value: uint32(7169)},
			{Name: "GL_SELECT", Value: uint32(7170)},
			{Name: "GL_FLAT", Value: uint32(7424)},
			{Name: "GL_SMOOTH", Value: uint32(7425)},
			{Name: "GL_KEEP", Value: uint32(7680)},
			{Name: "GL_REPLACE", Value: uint32(7681)},
			{Name: "GL_INCR", Value: uint32(7682)},
			{Name: "GL_DECR", Value: uint32(7683)},
			{Name: "GL_VENDOR", Value: uint32(7936)},
			{Name: "GL_RENDERER", Value: uint32(7937)},
			{Name: "GL_VERSION", Value: uint32(7938)},
			{Name: "GL_EXTENSIONS", Value: uint32(7939)},
			{Name: "GL_S", Value: uint32(8192)},
			{Name: "GL_T", Value: uint32(8193)},
			{Name: "GL_R", Value: uint32(8194)},
			{Name: "GL_Q", Value: uint32(8195)},
			{Name: "GL_MODULATE", Value: uint32(8448)},
			{Name: "GL_DECAL", Value: uint32(8449)},
			{Name: "GL_TEXTURE_ENV_MODE", Value: uint32(8704)},
			{Name: "GL_TEXTURE_ENV_COLOR", Value: uint32(8705)},
			{Name: "GL_TEXTURE_ENV", Value: uint32(8960)},
			{Name: "GL_EYE_LINEAR_NV", Value: uint32(9216)},
			{Name: "GL_EYE_LINEAR", Value: uint32(9216)},
			{Name: "GL_OBJECT_LINEAR_NV", Value: uint32(9217)},
			{Name: "GL_OBJECT_LINEAR", Value: uint32(9217)},
			{Name: "GL_SPHERE_MAP", Value: uint32(9218)},
			{Name: "GL_TEXTURE_GEN_MODE", Value: uint32(9472)},
			{Name: "GL_TEXTURE_GEN_MODE_OES", Value: uint32(9472)},
			{Name: "GL_OBJECT_PLANE", Value: uint32(9473)},
			{Name: "GL_EYE_PLANE", Value: uint32(9474)},
			{Name: "GL_NEAREST", Value: uint32(9728)},
			{Name: "GL_LINEAR", Value: uint32(9729)},
			{Name: "GL_NEAREST_MIPMAP_NEAREST", Value: uint32(9984)},
			{Name: "GL_LINEAR_MIPMAP_NEAREST", Value: uint32(9985)},
			{Name: "GL_NEAREST_MIPMAP_LINEAR", Value: uint32(9986)},
			{Name: "GL_LINEAR_MIPMAP_LINEAR", Value: uint32(9987)},
			{Name: "GL_TEXTURE_MAG_FILTER", Value: uint32(10240)},
			{Name: "GL_TEXTURE_MIN_FILTER", Value: uint32(10241)},
			{Name: "GL_TEXTURE_WRAP_S", Value: uint32(10242)},
			{Name: "GL_TEXTURE_WRAP_T", Value: uint32(10243)},
			{Name: "GL_CLAMP", Value: uint32(10496)},
			{Name: "GL_REPEAT", Value: uint32(10497)},
			{Name: "GL_POLYGON_OFFSET_UNITS", Value: uint32(10752)},
			{Name: "GL_POLYGON_OFFSET_POINT", Value: uint32(10753)},
			{Name: "GL_POLYGON_OFFSET_POINT_NV", Value: uint32(10753)},
			{Name: "GL_POLYGON_OFFSET_LINE_NV", Value: uint32(10754)},
			{Name: "GL_POLYGON_OFFSET_LINE", Value: uint32(10754)},
			{Name: "GL_R3_G3_B2", Value: uint32(10768)},
			{Name: "GL_V2F", Value: uint32(10784)},
			{Name: "GL_V3F", Value: uint32(10785)},
			{Name: "GL_C4UB_V2F", Value: uint32(10786)},
			{Name: "GL_C4UB_V3F", Value: uint32(10787)},
			{Name: "GL_C3F_V3F", Value: uint32(10788)},
			{Name: "GL_N3F_V3F", Value: uint32(10789)},
			{Name: "GL_C4F_N3F_V3F", Value: uint32(10790)},
			{Name: "GL_T2F_V3F", Value: uint32(10791)},
			{Name: "GL_T4F_V4F", Value: uint32(10792)},
			{Name: "GL_T2F_C4UB_V3F", Value: uint32(10793)},
			{Name: "GL_T2F_C3F_V3F", Value: uint32(10794)},
			{Name: "GL_T2F_N3F_V3F", Value: uint32(10795)},
			{Name: "GL_T2F_C4F_N3F_V3F", Value: uint32(10796)},
			{Name: "GL_T4F_C4F_N3F_V4F", Value: uint32(10797)},
			{Name: "GL_CLIP_DISTANCE0", Value: uint32(12288)},
			{Name: "GL_CLIP_DISTANCE0_APPLE", Value: uint32(12288)},
			{Name: "GL_CLIP_PLANE0", Value: uint32(12288)},
			{Name: "GL_CLIP_PLANE0_IMG", Value: uint32(12288)},
			{Name: "GL_CLIP_DISTANCE1", Value: uint32(12289)},
			{Name: "GL_CLIP_PLANE1_IMG", Value: uint32(12289)},
			{Name: "GL_CLIP_DISTANCE1_APPLE", Value: uint32(12289)},
			{Name: "GL_CLIP_PLANE1", Value: uint32(12289)},
			{Name: "GL_CLIP_DISTANCE2_APPLE", Value: uint32(12290)},
			{Name: "GL_CLIP_PLANE2_IMG", Value: uint32(12290)},
			{Name: "GL_CLIP_DISTANCE2", Value: uint32(12290)},
			{Name: "GL_CLIP_PLANE2", Value: uint32(12290)},
			{Name: "GL_CLIP_PLANE3", Value: uint32(12291)},
			{Name: "GL_CLIP_DISTANCE3", Value: uint32(12291)},
			{Name: "GL_CLIP_DISTANCE3_APPLE", Value: uint32(12291)},
			{Name: "GL_CLIP_PLANE3_IMG", Value: uint32(12291)},
			{Name: "GL_CLIP_PLANE4", Value: uint32(12292)},
			{Name: "GL_CLIP_DISTANCE4_APPLE", Value: uint32(12292)},
			{Name: "GL_CLIP_DISTANCE4", Value: uint32(12292)},
			{Name: "GL_CLIP_PLANE4_IMG", Value: uint32(12292)},
			{Name: "GL_CLIP_PLANE5_IMG", Value: uint32(12293)},
			{Name: "GL_CLIP_DISTANCE5", Value: uint32(12293)},
			{Name: "GL_CLIP_PLANE5", Value: uint32(12293)},
			{Name: "GL_CLIP_DISTANCE5_APPLE", Value: uint32(12293)},
			{Name: "GL_CLIP_DISTANCE6_APPLE", Value: uint32(12294)},
			{Name: "GL_CLIP_DISTANCE6", Value: uint32(12294)},
			{Name: "GL_CLIP_DISTANCE7", Value: uint32(12295)},
			{Name: "GL_CLIP_DISTANCE7_APPLE", Value: uint32(12295)},
			{Name: "GL_LIGHT0", Value: uint32(16384)},
			{Name: "GL_LIGHT1", Value: uint32(16385)},
			{Name: "GL_LIGHT2", Value: uint32(16386)},
			{Name: "GL_LIGHT3", Value: uint32(16387)},
			{Name: "GL_LIGHT4", Value: uint32(16388)},
			{Name: "GL_LIGHT5", Value: uint32(16389)},
			{Name: "GL_LIGHT6", Value: uint32(16390)},
			{Name: "GL_LIGHT7", Value: uint32(16391)},
			{Name: "GL_ABGR_EXT", Value: uint32(32768)},
			{Name: "GL_CONSTANT_COLOR_EXT", Value: uint32(32769)},
			{Name: "GL_CONSTANT_COLOR", Value: uint32(32769)},
			{Name: "GL_ONE_MINUS_CONSTANT_COLOR_EXT", Value: uint32(32770)},
			{Name: "GL_ONE_MINUS_CONSTANT_COLOR", Value: uint32(32770)},
			{Name: "GL_CONSTANT_ALPHA", Value: uint32(32771)},
			{Name: "GL_CONSTANT_ALPHA_EXT", Value: uint32(32771)},
			{Name: "GL_ONE_MINUS_CONSTANT_ALPHA", Value: uint32(32772)},
			{Name: "GL_ONE_MINUS_CONSTANT_ALPHA_EXT", Value: uint32(32772)},
			{Name: "GL_BLEND_COLOR", Value: uint32(32773)},
			{Name: "GL_BLEND_COLOR_EXT", Value: uint32(32773)},
			{Name: "GL_FUNC_ADD_OES", Value: uint32(32774)},
			{Name: "GL_FUNC_ADD", Value: uint32(32774)},
			{Name: "GL_FUNC_ADD_EXT", Value: uint32(32774)},
			{Name: "GL_MIN_EXT", Value: uint32(32775)},
			{Name: "GL_MIN", Value: uint32(32775)},
			{Name: "GL_MAX_EXT", Value: uint32(32776)},
			{Name: "GL_MAX", Value: uint32(32776)},
			{Name: "GL_BLEND_EQUATION_EXT", Value: uint32(32777)},
			{Name: "GL_BLEND_EQUATION_RGB_OES", Value: uint32(32777)},
			{Name: "GL_BLEND_EQUATION_OES", Value: uint32(32777)},
			{Name: "GL_BLEND_EQUATION", Value: uint32(32777)},
			{Name: "GL_BLEND_EQUATION_RGB", Value: uint32(32777)},
			{Name: "GL_BLEND_EQUATION_RGB_EXT", Value: uint32(32777)},
			{Name: "GL_FUNC_SUBTRACT_OES", Value: uint32(32778)},
			{Name: "GL_FUNC_SUBTRACT", Value: uint32(32778)},
			{Name: "GL_FUNC_SUBTRACT_EXT", Value: uint32(32778)},
			{Name: "GL_FUNC_REVERSE_SUBTRACT_OES", Value: uint32(32779)},
			{Name: "GL_FUNC_REVERSE_SUBTRACT", Value: uint32(32779)},
			{Name: "GL_FUNC_REVERSE_SUBTRACT_EXT", Value: uint32(32779)},
			{Name: "GL_CMYK_EXT", Value: uint32(32780)},
			{Name: "GL_CMYKA_EXT", Value: uint32(32781)},
			{Name: "GL_PACK_CMYK_HINT_EXT", Value: uint32(32782)},
			{Name: "GL_UNPACK_CMYK_HINT_EXT", Value: uint32(32783)},
			{Name: "GL_CONVOLUTION_1D_EXT", Value: uint32(32784)},
			{Name: "GL_CONVOLUTION_1D", Value: uint32(32784)},
			{Name: "GL_CONVOLUTION_2D", Value: uint32(32785)},
			{Name: "GL_CONVOLUTION_2D_EXT", Value: uint32(32785)},
			{Name: "GL_SEPARABLE_2D_EXT", Value: uint32(32786)},
			{Name: "GL_SEPARABLE_2D", Value: uint32(32786)},
			{Name: "GL_CONVOLUTION_BORDER_MODE_EXT", Value: uint32(32787)},
			{Name: "GL_CONVOLUTION_BORDER_MODE", Value: uint32(32787)},
			{Name: "GL_CONVOLUTION_FILTER_SCALE_EXT", Value: uint32(32788)},
			{Name: "GL_CONVOLUTION_FILTER_SCALE", Value: uint32(32788)},
			{Name: "GL_CONVOLUTION_FILTER_BIAS_EXT", Value: uint32(32789)},
			{Name: "GL_CONVOLUTION_FILTER_BIAS", Value: uint32(32789)},
			{Name: "GL_REDUCE", Value: uint32(32790)},
			{Name: "GL_REDUCE_EXT", Value: uint32(32790)},
			{Name: "GL_CONVOLUTION_FORMAT", Value: uint32(32791)},
			{Name: "GL_CONVOLUTION_FORMAT_EXT", Value: uint32(32791)},
			{Name: "GL_CONVOLUTION_WIDTH_EXT", Value: uint32(32792)},
			{Name: "GL_CONVOLUTION_WIDTH", Value: uint32(32792)},
			{Name: "GL_CONVOLUTION_HEIGHT", Value: uint32(32793)},
			{Name: "GL_CONVOLUTION_HEIGHT_EXT", Value: uint32(32793)},
			{Name: "GL_MAX_CONVOLUTION_WIDTH", Value: uint32(32794)},
			{Name: "GL_MAX_CONVOLUTION_WIDTH_EXT", Value: uint32(32794)},
			{Name: "GL_MAX_CONVOLUTION_HEIGHT_EXT", Value: uint32(32795)},
			{Name: "GL_MAX_CONVOLUTION_HEIGHT", Value: uint32(32795)},
			{Name: "GL_POST_CONVOLUTION_RED_SCALE", Value: uint32(32796)},
			{Name: "GL_POST_CONVOLUTION_RED_SCALE_EXT", Value: uint32(32796)},
			{Name: "GL_POST_CONVOLUTION_GREEN_SCALE_EXT", Value: uint32(32797)},
			{Name: "GL_POST_CONVOLUTION_GREEN_SCALE", Value: uint32(32797)},
			{Name: "GL_POST_CONVOLUTION_BLUE_SCALE", Value: uint32(32798)},
			{Name: "GL_POST_CONVOLUTION_BLUE_SCALE_EXT", Value: uint32(32798)},
			{Name: "GL_POST_CONVOLUTION_ALPHA_SCALE", Value: uint32(32799)},
			{Name: "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT", Value: uint32(32799)},
			{Name: "GL_POST_CONVOLUTION_RED_BIAS_EXT", Value: uint32(32800)},
			{Name: "GL_POST_CONVOLUTION_RED_BIAS", Value: uint32(32800)},
			{Name: "GL_POST_CONVOLUTION_GREEN_BIAS_EXT", Value: uint32(32801)},
			{Name: "GL_POST_CONVOLUTION_GREEN_BIAS", Value: uint32(32801)},
			{Name: "GL_POST_CONVOLUTION_BLUE_BIAS", Value: uint32(32802)},
			{Name: "GL_POST_CONVOLUTION_BLUE_BIAS_EXT", Value: uint32(32802)},
			{Name: "GL_POST_CONVOLUTION_ALPHA_BIAS", Value: uint32(32803)},
			{Name: "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT", Value: uint32(32803)},
			{Name: "GL_HISTOGRAM", Value: uint32(32804)},
			{Name: "GL_HISTOGRAM_EXT", Value: uint32(32804)},
			{Name: "GL_PROXY_HISTOGRAM_EXT", Value: uint32(32805)},
			{Name: "GL_PROXY_HISTOGRAM", Value: uint32(32805)},
			{Name: "GL_HISTOGRAM_WIDTH", Value: uint32(32806)},
			{Name: "GL_HISTOGRAM_WIDTH_EXT", Value: uint32(32806)},
			{Name: "GL_HISTOGRAM_FORMAT_EXT", Value: uint32(32807)},
			{Name: "GL_HISTOGRAM_FORMAT", Value: uint32(32807)},
			{Name: "GL_HISTOGRAM_RED_SIZE", Value: uint32(32808)},
			{Name: "GL_HISTOGRAM_RED_SIZE_EXT", Value: uint32(32808)},
			{Name: "GL_HISTOGRAM_GREEN_SIZE", Value: uint32(32809)},
			{Name: "GL_HISTOGRAM_GREEN_SIZE_EXT", Value: uint32(32809)},
			{Name: "GL_HISTOGRAM_BLUE_SIZE", Value: uint32(32810)},
			{Name: "GL_HISTOGRAM_BLUE_SIZE_EXT", Value: uint32(32810)},
			{Name: "GL_HISTOGRAM_ALPHA_SIZE", Value: uint32(32811)},
			{Name: "GL_HISTOGRAM_ALPHA_SIZE_EXT", Value: uint32(32811)},
			{Name: "GL_HISTOGRAM_LUMINANCE_SIZE_EXT", Value: uint32(32812)},
			{Name: "GL_HISTOGRAM_LUMINANCE_SIZE", Value: uint32(32812)},
			{Name: "GL_HISTOGRAM_SINK", Value: uint32(32813)},
			{Name: "GL_HISTOGRAM_SINK_EXT", Value: uint32(32813)},
			{Name: "GL_MINMAX", Value: uint32(32814)},
			{Name: "GL_MINMAX_EXT", Value: uint32(32814)},
			{Name: "GL_MINMAX_FORMAT_EXT", Value: uint32(32815)},
			{Name: "GL_MINMAX_FORMAT", Value: uint32(32815)},
			{Name: "GL_MINMAX_SINK", Value: uint32(32816)},
			{Name: "GL_MINMAX_SINK_EXT", Value: uint32(32816)},
			{Name: "GL_TABLE_TOO_LARGE_EXT", Value: uint32(32817)},
			{Name: "GL_TABLE_TOO_LARGE", Value: uint32(32817)},
			{Name: "GL_UNSIGNED_BYTE_3_3_2_EXT", Value: uint32(32818)},
			{Name: "GL_UNSIGNED_BYTE_3_3_2", Value: uint32(32818)},
			{Name: "GL_UNSIGNED_SHORT_4_4_4_4", Value: uint32(32819)},
			{Name: "GL_UNSIGNED_SHORT_4_4_4_4_EXT", Value: uint32(32819)},
			{Name: "GL_UNSIGNED_SHORT_5_5_5_1", Value: uint32(32820)},
			{Name: "GL_UNSIGNED_SHORT_5_5_5_1_EXT", Value: uint32(32820)},
			{Name: "GL_UNSIGNED_INT_8_8_8_8_EXT", Value: uint32(32821)},
			{Name: "GL_UNSIGNED_INT_8_8_8_8", Value: uint32(32821)},
			{Name: "GL_UNSIGNED_INT_10_10_10_2_EXT", Value: uint32(32822)},
			{Name: "GL_UNSIGNED_INT_10_10_10_2", Value: uint32(32822)},
			{Name: "GL_POLYGON_OFFSET_EXT", Value: uint32(32823)},
			{Name: "GL_POLYGON_OFFSET_FILL", Value: uint32(32823)},
			{Name: "GL_POLYGON_OFFSET_FACTOR", Value: uint32(32824)},
			{Name: "GL_POLYGON_OFFSET_FACTOR_EXT", Value: uint32(32824)},
			{Name: "GL_POLYGON_OFFSET_BIAS_EXT", Value: uint32(32825)},
			{Name: "GL_RESCALE_NORMAL_EXT", Value: uint32(32826)},
			{Name: "GL_RESCALE_NORMAL", Value: uint32(32826)},
			{Name: "GL_ALPHA4_EXT", Value: uint32(32827)},
			{Name: "GL_ALPHA4", Value: uint32(32827)},
			{Name: "GL_ALPHA8_EXT", Value: uint32(32828)},
			{Name: "GL_ALPHA8_OES", Value: uint32(32828)},
			{Name: "GL_ALPHA8", Value: uint32(32828)},
			{Name: "GL_ALPHA12", Value: uint32(32829)},
			{Name: "GL_ALPHA12_EXT", Value: uint32(32829)},
			{Name: "GL_ALPHA16", Value: uint32(32830)},
			{Name: "GL_ALPHA16_EXT", Value: uint32(32830)},
			{Name: "GL_LUMINANCE4", Value: uint32(32831)},
			{Name: "GL_LUMINANCE4_EXT", Value: uint32(32831)},
			{Name: "GL_LUMINANCE8_OES", Value: uint32(32832)},
			{Name: "GL_LUMINANCE8_EXT", Value: uint32(32832)},
			{Name: "GL_LUMINANCE8", Value: uint32(32832)},
			{Name: "GL_LUMINANCE12_EXT", Value: uint32(32833)},
			{Name: "GL_LUMINANCE12", Value: uint32(32833)},
			{Name: "GL_LUMINANCE16_EXT", Value: uint32(32834)},
			{Name: "GL_LUMINANCE16", Value: uint32(32834)},
			{Name: "GL_LUMINANCE4_ALPHA4_OES", Value: uint32(32835)},
			{Name: "GL_LUMINANCE4_ALPHA4", Value: uint32(32835)},
			{Name: "GL_LUMINANCE4_ALPHA4_EXT", Value: uint32(32835)},
			{Name: "GL_LUMINANCE6_ALPHA2", Value: uint32(32836)},
			{Name: "GL_LUMINANCE6_ALPHA2_EXT", Value: uint32(32836)},
			{Name: "GL_LUMINANCE8_ALPHA8_EXT", Value: uint32(32837)},
			{Name: "GL_LUMINANCE8_ALPHA8", Value: uint32(32837)},
			{Name: "GL_LUMINANCE8_ALPHA8_OES", Value: uint32(32837)},
			{Name: "GL_LUMINANCE12_ALPHA4", Value: uint32(32838)},
			{Name: "GL_LUMINANCE12_ALPHA4_EXT", Value: uint32(32838)},
			{Name: "GL_LUMINANCE12_ALPHA12_EXT", Value: uint32(32839)},
			{Name: "GL_LUMINANCE12_ALPHA12", Value: uint32(32839)},
			{Name: "GL_LUMINANCE16_ALPHA16_EXT", Value: uint32(32840)},
			{Name: "GL_LUMINANCE16_ALPHA16", Value: uint32(32840)},
			{Name: "GL_INTENSITY_EXT", Value: uint32(32841)},
			{Name: "GL_INTENSITY", Value: uint32(32841)},
			{Name: "GL_INTENSITY4", Value: uint32(32842)},
			{Name: "GL_INTENSITY4_EXT", Value: uint32(32842)},
			{Name: "GL_INTENSITY8_EXT", Value: uint32(32843)},
			{Name: "GL_INTENSITY8", Value: uint32(32843)},
			{Name: "GL_INTENSITY12", Value: uint32(32844)},
			{Name: "GL_INTENSITY12_EXT", Value: uint32(32844)},
			{Name: "GL_INTENSITY16", Value: uint32(32845)},
			{Name: "GL_INTENSITY16_EXT", Value: uint32(32845)},
			{Name: "GL_RGB2_EXT", Value: uint32(32846)},
			{Name: "GL_RGB4", Value: uint32(32847)},
			{Name: "GL_RGB4_EXT", Value: uint32(32847)},
			{Name: "GL_RGB5_EXT", Value: uint32(32848)},
			{Name: "GL_RGB5", Value: uint32(32848)},
			{Name: "GL_RGB8", Value: uint32(32849)},
			{Name: "GL_RGB8_OES", Value: uint32(32849)},
			{Name: "GL_RGB8_EXT", Value: uint32(32849)},
			{Name: "GL_RGB10_EXT", Value: uint32(32850)},
			{Name: "GL_RGB10", Value: uint32(32850)},
			{Name: "GL_RGB12", Value: uint32(32851)},
			{Name: "GL_RGB12_EXT", Value: uint32(32851)},
			{Name: "GL_RGB16", Value: uint32(32852)},
			{Name: "GL_RGB16_EXT", Value: uint32(32852)},
			{Name: "GL_RGBA2", Value: uint32(32853)},
			{Name: "GL_RGBA2_EXT", Value: uint32(32853)},
			{Name: "GL_RGBA4_EXT", Value: uint32(32854)},
			{Name: "GL_RGBA4_OES", Value: uint32(32854)},
			{Name: "GL_RGBA4", Value: uint32(32854)},
			{Name: "GL_RGB5_A1_OES", Value: uint32(32855)},
			{Name: "GL_RGB5_A1", Value: uint32(32855)},
			{Name: "GL_RGB5_A1_EXT", Value: uint32(32855)},
			{Name: "GL_RGBA8_EXT", Value: uint32(32856)},
			{Name: "GL_RGBA8", Value: uint32(32856)},
			{Name: "GL_RGBA8_OES", Value: uint32(32856)},
			{Name: "GL_RGB10_A2_EXT", Value: uint32(32857)},
			{Name: "GL_RGB10_A2", Value: uint32(32857)},
			{Name: "GL_RGBA12_EXT", Value: uint32(32858)},
			{Name: "GL_RGBA12", Value: uint32(32858)},
			{Name: "GL_RGBA16", Value: uint32(32859)},
			{Name: "GL_RGBA16_EXT", Value: uint32(32859)},
			{Name: "GL_TEXTURE_RED_SIZE_EXT", Value: uint32(32860)},
			{Name: "GL_TEXTURE_RED_SIZE", Value: uint32(32860)},
			{Name: "GL_TEXTURE_GREEN_SIZE", Value: uint32(32861)},
			{Name: "GL_TEXTURE_GREEN_SIZE_EXT", Value: uint32(32861)},
			{Name: "GL_TEXTURE_BLUE_SIZE_EXT", Value: uint32(32862)},
			{Name: "GL_TEXTURE_BLUE_SIZE", Value: uint32(32862)},
			{Name: "GL_TEXTURE_ALPHA_SIZE_EXT", Value: uint32(32863)},
			{Name: "GL_TEXTURE_ALPHA_SIZE", Value: uint32(32863)},
			{Name: "GL_TEXTURE_LUMINANCE_SIZE_EXT", Value: uint32(32864)},
			{Name: "GL_TEXTURE_LUMINANCE_SIZE", Value: uint32(32864)},
			{Name: "GL_TEXTURE_INTENSITY_SIZE", Value: uint32(32865)},
			{Name: "GL_TEXTURE_INTENSITY_SIZE_EXT", Value: uint32(32865)},
			{Name: "GL_REPLACE_EXT", Value: uint32(32866)},
			{Name: "GL_PROXY_TEXTURE_1D_EXT", Value: uint32(32867)},
			{Name: "GL_PROXY_TEXTURE_1D", Value: uint32(32867)},
			{Name: "GL_PROXY_TEXTURE_2D_EXT", Value: uint32(32868)},
			{Name: "GL_PROXY_TEXTURE_2D", Value: uint32(32868)},
			{Name: "GL_TEXTURE_TOO_LARGE_EXT", Value: uint32(32869)},
			{Name: "GL_TEXTURE_PRIORITY", Value: uint32(32870)},
			{Name: "GL_TEXTURE_PRIORITY_EXT", Value: uint32(32870)},
			{Name: "GL_TEXTURE_RESIDENT", Value: uint32(32871)},
			{Name: "GL_TEXTURE_RESIDENT_EXT", Value: uint32(32871)},
			{Name: "GL_TEXTURE_1D_BINDING_EXT", Value: uint32(32872)},
			{Name: "GL_TEXTURE_BINDING_1D", Value: uint32(32872)},
			{Name: "GL_TEXTURE_2D_BINDING_EXT", Value: uint32(32873)},
			{Name: "GL_TEXTURE_BINDING_2D", Value: uint32(32873)},
			{Name: "GL_TEXTURE_BINDING_3D_OES", Value: uint32(32874)},
			{Name: "GL_TEXTURE_3D_BINDING_OES", Value: uint32(32874)},
			{Name: "GL_TEXTURE_BINDING_3D", Value: uint32(32874)},
			{Name: "GL_TEXTURE_3D_BINDING_EXT", Value: uint32(32874)},
			{Name: "GL_PACK_SKIP_IMAGES", Value: uint32(32875)},
			{Name: "GL_PACK_SKIP_IMAGES_EXT", Value: uint32(32875)},
			{Name: "GL_PACK_IMAGE_HEIGHT", Value: uint32(32876)},
			{Name: "GL_PACK_IMAGE_HEIGHT_EXT", Value: uint32(32876)},
			{Name: "GL_UNPACK_SKIP_IMAGES_EXT", Value: uint32(32877)},
			{Name: "GL_UNPACK_SKIP_IMAGES", Value: uint32(32877)},
			{Name: "GL_UNPACK_IMAGE_HEIGHT", Value: uint32(32878)},
			{Name: "GL_UNPACK_IMAGE_HEIGHT_EXT", Value: uint32(32878)},
			{Name: "GL_TEXTURE_3D_OES", Value: uint32(32879)},
			{Name: "GL_TEXTURE_3D", Value: uint32(32879)},
			{Name: "GL_TEXTURE_3D_EXT", Value: uint32(32879)},
			{Name: "GL_PROXY_TEXTURE_3D", Value: uint32(32880)},
			{Name: "GL_PROXY_TEXTURE_3D_EXT", Value: uint32(32880)},
			{Name: "GL_TEXTURE_DEPTH_EXT", Value: uint32(32881)},
			{Name: "GL_TEXTURE_DEPTH", Value: uint32(32881)},
			{Name: "GL_TEXTURE_WRAP_R", Value: uint32(32882)},
			{Name: "GL_TEXTURE_WRAP_R_EXT", Value: uint32(32882)},
			{Name: "GL_TEXTURE_WRAP_R_OES", Value: uint32(32882)},
			{Name: "GL_MAX_3D_TEXTURE_SIZE_OES", Value: uint32(32883)},
			{Name: "GL_MAX_3D_TEXTURE_SIZE", Value: uint32(32883)},
			{Name: "GL_MAX_3D_TEXTURE_SIZE_EXT", Value: uint32(32883)},
			{Name: "GL_VERTEX_ARRAY", Value: uint32(32884)},
			{Name: "GL_VERTEX_ARRAY_KHR", Value: uint32(32884)},
			{Name: "GL_VERTEX_ARRAY_EXT", Value: uint32(32884)},
			{Name: "GL_NORMAL_ARRAY", Value: uint32(32885)},
			{Name: "GL_NORMAL_ARRAY_EXT", Value: uint32(32885)},
			{Name: "GL_COLOR_ARRAY", Value: uint32(32886)},
			{Name: "GL_COLOR_ARRAY_EXT", Value: uint32(32886)},
			{Name: "GL_INDEX_ARRAY_EXT", Value: uint32(32887)},
			{Name: "GL_INDEX_ARRAY", Value: uint32(32887)},
			{Name: "GL_TEXTURE_COORD_ARRAY_EXT", Value: uint32(32888)},
			{Name: "GL_TEXTURE_COORD_ARRAY", Value: uint32(32888)},
			{Name: "GL_EDGE_FLAG_ARRAY", Value: uint32(32889)},
			{Name: "GL_EDGE_FLAG_ARRAY_EXT", Value: uint32(32889)},
			{Name: "GL_VERTEX_ARRAY_SIZE", Value: uint32(32890)},
			{Name: "GL_VERTEX_ARRAY_SIZE_EXT", Value: uint32(32890)},
			{Name: "GL_VERTEX_ARRAY_TYPE", Value: uint32(32891)},
			{Name: "GL_VERTEX_ARRAY_TYPE_EXT", Value: uint32(32891)},
			{Name: "GL_VERTEX_ARRAY_STRIDE_EXT", Value: uint32(32892)},
			{Name: "GL_VERTEX_ARRAY_STRIDE", Value: uint32(32892)},
			{Name: "GL_VERTEX_ARRAY_COUNT_EXT", Value: uint32(32893)},
			{Name: "GL_NORMAL_ARRAY_TYPE", Value: uint32(32894)},
			{Name: "GL_NORMAL_ARRAY_TYPE_EXT", Value: uint32(32894)},
			{Name: "GL_NORMAL_ARRAY_STRIDE", Value: uint32(32895)},
			{Name: "GL_NORMAL_ARRAY_STRIDE_EXT", Value: uint32(32895)},
			{Name: "GL_NORMAL_ARRAY_COUNT_EXT", Value: uint32(32896)},
			{Name: "GL_COLOR_ARRAY_SIZE", Value: uint32(32897)},
			{Name: "GL_COLOR_ARRAY_SIZE_EXT", Value: uint32(32897)},
			{Name: "GL_COLOR_ARRAY_TYPE_EXT", Value: uint32(32898)},
			{Name: "GL_COLOR_ARRAY_TYPE", Value: uint32(32898)},
			{Name: "GL_COLOR_ARRAY_STRIDE_EXT", Value: uint32(32899)},
			{Name: "GL_COLOR_ARRAY_STRIDE", Value: uint32(32899)},
			{Name: "GL_COLOR_ARRAY_COUNT_EXT", Value: uint32(32900)},
			{Name: "GL_INDEX_ARRAY_TYPE_EXT", Value: uint32(32901)},
			{Name: "GL_INDEX_ARRAY_TYPE", Value: uint32(32901)},
			{Name: "GL_INDEX_ARRAY_STRIDE", Value: uint32(32902)},
			{Name: "GL_INDEX_ARRAY_STRIDE_EXT", Value: uint32(32902)},
			{Name: "GL_INDEX_ARRAY_COUNT_EXT", Value: uint32(32903)},
			{Name: "GL_TEXTURE_COORD_ARRAY_SIZE", Value: uint32(32904)},
			{Name: "GL_TEXTURE_COORD_ARRAY_SIZE_EXT", Value: uint32(32904)},
			{Name: "GL_TEXTURE_COORD_ARRAY_TYPE", Value: uint32(32905)},
			{Name: "GL_TEXTURE_COORD_ARRAY_TYPE_EXT", Value: uint32(32905)},
			{Name: "GL_TEXTURE_COORD_ARRAY_STRIDE", Value: uint32(32906)},
			{Name: "GL_TEXTURE_COORD_ARRAY_STRIDE_EXT", Value: uint32(32906)},
			{Name: "GL_TEXTURE_COORD_ARRAY_COUNT_EXT", Value: uint32(32907)},
			{Name: "GL_EDGE_FLAG_ARRAY_STRIDE_EXT", Value: uint32(32908)},
			{Name: "GL_EDGE_FLAG_ARRAY_STRIDE", Value: uint32(32908)},
			{Name: "GL_EDGE_FLAG_ARRAY_COUNT_EXT", Value: uint32(32909)},
			{Name: "GL_VERTEX_ARRAY_POINTER_EXT", Value: uint32(32910)},
			{Name: "GL_VERTEX_ARRAY_POINTER", Value: uint32(32910)},
			{Name: "GL_NORMAL_ARRAY_POINTER_EXT", Value: uint32(32911)},
			{Name: "GL_NORMAL_ARRAY_POINTER", Value: uint32(32911)},
			{Name: "GL_COLOR_ARRAY_POINTER", Value: uint32(32912)},
			{Name: "GL_COLOR_ARRAY_POINTER_EXT", Value: uint32(32912)},
			{Name: "GL_INDEX_ARRAY_POINTER", Value: uint32(32913)},
			{Name: "GL_INDEX_ARRAY_POINTER_EXT", Value: uint32(32913)},
			{Name: "GL_TEXTURE_COORD_ARRAY_POINTER", Value: uint32(32914)},
			{Name: "GL_TEXTURE_COORD_ARRAY_POINTER_EXT", Value: uint32(32914)},
			{Name: "GL_EDGE_FLAG_ARRAY_POINTER", Value: uint32(32915)},
			{Name: "GL_EDGE_FLAG_ARRAY_POINTER_EXT", Value: uint32(32915)},
			{Name: "GL_INTERLACE_SGIX", Value: uint32(32916)},
			{Name: "GL_DETAIL_TEXTURE_2D_SGIS", Value: uint32(32917)},
			{Name: "GL_DETAIL_TEXTURE_2D_BINDING_SGIS", Value: uint32(32918)},
			{Name: "GL_LINEAR_DETAIL_SGIS", Value: uint32(32919)},
			{Name: "GL_LINEAR_DETAIL_ALPHA_SGIS", Value: uint32(32920)},
			{Name: "GL_LINEAR_DETAIL_COLOR_SGIS", Value: uint32(32921)},
			{Name: "GL_DETAIL_TEXTURE_LEVEL_SGIS", Value: uint32(32922)},
			{Name: "GL_DETAIL_TEXTURE_MODE_SGIS", Value: uint32(32923)},
			{Name: "GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS", Value: uint32(32924)},
			{Name: "GL_MULTISAMPLE_SGIS", Value: uint32(32925)},
			{Name: "GL_MULTISAMPLE_EXT", Value: uint32(32925)},
			{Name: "GL_MULTISAMPLE_ARB", Value: uint32(32925)},
			{Name: "GL_MULTISAMPLE", Value: uint32(32925)},
			{Name: "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB", Value: uint32(32926)},
			{Name: "GL_SAMPLE_ALPHA_TO_MASK_SGIS", Value: uint32(32926)},
			{Name: "GL_SAMPLE_ALPHA_TO_COVERAGE", Value: uint32(32926)},
			{Name: "GL_SAMPLE_ALPHA_TO_MASK_EXT", Value: uint32(32926)},
			{Name: "GL_SAMPLE_ALPHA_TO_ONE_EXT", Value: uint32(32927)},
			{Name: "GL_SAMPLE_ALPHA_TO_ONE", Value: uint32(32927)},
			{Name: "GL_SAMPLE_ALPHA_TO_ONE_ARB", Value: uint32(32927)},
			{Name: "GL_SAMPLE_ALPHA_TO_ONE_SGIS", Value: uint32(32927)},
			{Name: "GL_SAMPLE_MASK_EXT", Value: uint32(32928)},
			{Name: "GL_SAMPLE_COVERAGE_ARB", Value: uint32(32928)},
			{Name: "GL_SAMPLE_MASK_SGIS", Value: uint32(32928)},
			{Name: "GL_SAMPLE_COVERAGE", Value: uint32(32928)},
			{Name: "GL_1PASS_EXT", Value: uint32(32929)},
			{Name: "GL_1PASS_SGIS", Value: uint32(32929)},
			{Name: "GL_2PASS_0_SGIS", Value: uint32(32930)},
			{Name: "GL_2PASS_0_EXT", Value: uint32(32930)},
			{Name: "GL_2PASS_1_EXT", Value: uint32(32931)},
			{Name: "GL_2PASS_1_SGIS", Value: uint32(32931)},
			{Name: "GL_4PASS_0_EXT", Value: uint32(32932)},
			{Name: "GL_4PASS_0_SGIS", Value: uint32(32932)},
			{Name: "GL_4PASS_1_EXT", Value: uint32(32933)},
			{Name: "GL_4PASS_1_SGIS", Value: uint32(32933)},
			{Name: "GL_4PASS_2_SGIS", Value: uint32(32934)},
			{Name: "GL_4PASS_2_EXT", Value: uint32(32934)},
			{Name: "GL_4PASS_3_EXT", Value: uint32(32935)},
			{Name: "GL_4PASS_3_SGIS", Value: uint32(32935)},
			{Name: "GL_SAMPLE_BUFFERS_SGIS", Value: uint32(32936)},
			{Name: "GL_SAMPLE_BUFFERS_ARB", Value: uint32(32936)},
			{Name: "GL_SAMPLE_BUFFERS", Value: uint32(32936)},
			{Name: "GL_SAMPLE_BUFFERS_EXT", Value: uint32(32936)},
			{Name: "GL_SAMPLES_SGIS", Value: uint32(32937)},
			{Name: "GL_SAMPLES_ARB", Value: uint32(32937)},
			{Name: "GL_SAMPLES", Value: uint32(32937)},
			{Name: "GL_SAMPLES_EXT", Value: uint32(32937)},
			{Name: "GL_SAMPLE_COVERAGE_VALUE_ARB", Value: uint32(32938)},
			{Name: "GL_SAMPLE_MASK_VALUE_SGIS", Value: uint32(32938)},
			{Name: "GL_SAMPLE_MASK_VALUE_EXT", Value: uint32(32938)},
			{Name: "GL_SAMPLE_COVERAGE_VALUE", Value: uint32(32938)},
			{Name: "GL_SAMPLE_COVERAGE_INVERT", Value: uint32(32939)},
			{Name: "GL_SAMPLE_MASK_INVERT_EXT", Value: uint32(32939)},
			{Name: "GL_SAMPLE_COVERAGE_INVERT_ARB", Value: uint32(32939)},
			{Name: "GL_SAMPLE_MASK_INVERT_SGIS", Value: uint32(32939)},
			{Name: "GL_SAMPLE_PATTERN_EXT", Value: uint32(32940)},
			{Name: "GL_SAMPLE_PATTERN_SGIS", Value: uint32(32940)},
			{Name: "GL_LINEAR_SHARPEN_SGIS", Value: uint32(32941)},
			{Name: "GL_LINEAR_SHARPEN_ALPHA_SGIS", Value: uint32(32942)},
			{Name: "GL_LINEAR_SHARPEN_COLOR_SGIS", Value: uint32(32943)},
			{Name: "GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS", Value: uint32(32944)},
			{Name: "GL_COLOR_MATRIX", Value: uint32(32945)},
			{Name: "GL_COLOR_MATRIX_SGI", Value: uint32(32945)},
			{Name: "GL_COLOR_MATRIX_STACK_DEPTH", Value: uint32(32946)},
			{Name: "GL_COLOR_MATRIX_STACK_DEPTH_SGI", Value: uint32(32946)},
			{Name: "GL_MAX_COLOR_MATRIX_STACK_DEPTH", Value: uint32(32947)},
			{Name: "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI", Value: uint32(32947)},
			{Name: "GL_POST_COLOR_MATRIX_RED_SCALE_SGI", Value: uint32(32948)},
			{Name: "GL_POST_COLOR_MATRIX_RED_SCALE", Value: uint32(32948)},
			{Name: "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI", Value: uint32(32949)},
			{Name: "GL_POST_COLOR_MATRIX_GREEN_SCALE", Value: uint32(32949)},
			{Name: "GL_POST_COLOR_MATRIX_BLUE_SCALE", Value: uint32(32950)},
			{Name: "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI", Value: uint32(32950)},
			{Name: "GL_POST_COLOR_MATRIX_ALPHA_SCALE", Value: uint32(32951)},
			{Name: "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI", Value: uint32(32951)},
			{Name: "GL_POST_COLOR_MATRIX_RED_BIAS_SGI", Value: uint32(32952)},
			{Name: "GL_POST_COLOR_MATRIX_RED_BIAS", Value: uint32(32952)},
			{Name: "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI", Value: uint32(32953)},
			{Name: "GL_POST_COLOR_MATRIX_GREEN_BIAS", Value: uint32(32953)},
			{Name: "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI", Value: uint32(32954)},
			{Name: "GL_POST_COLOR_MATRIX_BLUE_BIAS", Value: uint32(32954)},
			{Name: "GL_POST_COLOR_MATRIX_ALPHA_BIAS", Value: uint32(32955)},
			{Name: "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI", Value: uint32(32955)},
			{Name: "GL_TEXTURE_COLOR_TABLE_SGI", Value: uint32(32956)},
			{Name: "GL_PROXY_TEXTURE_COLOR_TABLE_SGI", Value: uint32(32957)},
			{Name: "GL_TEXTURE_ENV_BIAS_SGIX", Value: uint32(32958)},
			{Name: "GL_SHADOW_AMBIENT_SGIX", Value: uint32(32959)},
			{Name: "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB", Value: uint32(32959)},
			{Name: "GL_BLEND_DST_RGB_OES", Value: uint32(32968)},
			{Name: "GL_BLEND_DST_RGB", Value: uint32(32968)},
			{Name: "GL_BLEND_DST_RGB_EXT", Value: uint32(32968)},
			{Name: "GL_BLEND_SRC_RGB", Value: uint32(32969)},
			{Name: "GL_BLEND_SRC_RGB_EXT", Value: uint32(32969)},
			{Name: "GL_BLEND_SRC_RGB_OES", Value: uint32(32969)},
			{Name: "GL_BLEND_DST_ALPHA", Value: uint32(32970)},
			{Name: "GL_BLEND_DST_ALPHA_EXT", Value: uint32(32970)},
			{Name: "GL_BLEND_DST_ALPHA_OES", Value: uint32(32970)},
			{Name: "GL_BLEND_SRC_ALPHA_OES", Value: uint32(32971)},
			{Name: "GL_BLEND_SRC_ALPHA", Value: uint32(32971)},
			{Name: "GL_BLEND_SRC_ALPHA_EXT", Value: uint32(32971)},
			{Name: "GL_422_EXT", Value: uint32(32972)},
			{Name: "GL_422_REV_EXT", Value: uint32(32973)},
			{Name: "GL_422_AVERAGE_EXT", Value: uint32(32974)},
			{Name: "GL_422_REV_AVERAGE_EXT", Value: uint32(32975)},
			{Name: "GL_COLOR_TABLE", Value: uint32(32976)},
			{Name: "GL_COLOR_TABLE_SGI", Value: uint32(32976)},
			{Name: "GL_POST_CONVOLUTION_COLOR_TABLE", Value: uint32(32977)},
			{Name: "GL_POST_CONVOLUTION_COLOR_TABLE_SGI", Value: uint32(32977)},
			{Name: "GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI", Value: uint32(32978)},
			{Name: "GL_POST_COLOR_MATRIX_COLOR_TABLE", Value: uint32(32978)},
			{Name: "GL_PROXY_COLOR_TABLE", Value: uint32(32979)},
			{Name: "GL_PROXY_COLOR_TABLE_SGI", Value: uint32(32979)},
			{Name: "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI", Value: uint32(32980)},
			{Name: "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE", Value: uint32(32980)},
			{Name: "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE", Value: uint32(32981)},
			{Name: "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI", Value: uint32(32981)},
			{Name: "GL_COLOR_TABLE_SCALE_SGI", Value: uint32(32982)},
			{Name: "GL_COLOR_TABLE_SCALE", Value: uint32(32982)},
			{Name: "GL_COLOR_TABLE_BIAS_SGI", Value: uint32(32983)},
			{Name: "GL_COLOR_TABLE_BIAS", Value: uint32(32983)},
			{Name: "GL_COLOR_TABLE_FORMAT", Value: uint32(32984)},
			{Name: "GL_COLOR_TABLE_FORMAT_SGI", Value: uint32(32984)},
			{Name: "GL_COLOR_TABLE_WIDTH", Value: uint32(32985)},
			{Name: "GL_COLOR_TABLE_WIDTH_SGI", Value: uint32(32985)},
			{Name: "GL_COLOR_TABLE_RED_SIZE_SGI", Value: uint32(32986)},
			{Name: "GL_COLOR_TABLE_RED_SIZE", Value: uint32(32986)},
			{Name: "GL_COLOR_TABLE_GREEN_SIZE_SGI", Value: uint32(32987)},
			{Name: "GL_COLOR_TABLE_GREEN_SIZE", Value: uint32(32987)},
			{Name: "GL_COLOR_TABLE_BLUE_SIZE_SGI", Value: uint32(32988)},
			{Name: "GL_COLOR_TABLE_BLUE_SIZE", Value: uint32(32988)},
			{Name: "GL_COLOR_TABLE_ALPHA_SIZE", Value: uint32(32989)},
			{Name: "GL_COLOR_TABLE_ALPHA_SIZE_SGI", Value: uint32(32989)},
			{Name: "GL_COLOR_TABLE_LUMINANCE_SIZE_SGI", Value: uint32(32990)},
			{Name: "GL_COLOR_TABLE_LUMINANCE_SIZE", Value: uint32(32990)},
			{Name: "GL_COLOR_TABLE_INTENSITY_SIZE_SGI", Value: uint32(32991)},
			{Name: "GL_COLOR_TABLE_INTENSITY_SIZE", Value: uint32(32991)},
			{Name: "GL_BGR", Value: uint32(32992)},
			{Name: "GL_BGR_EXT", Value: uint32(32992)},
			{Name: "GL_BGRA_IMG", Value: uint32(32993)},
			{Name: "GL_BGRA", Value: uint32(32993)},
			{Name: "GL_BGRA_EXT", Value: uint32(32993)},
			{Name: "GL_COLOR_INDEX1_EXT", Value: uint32(32994)},
			{Name: "GL_COLOR_INDEX2_EXT", Value: uint32(32995)},
			{Name: "GL_COLOR_INDEX4_EXT", Value: uint32(32996)},
			{Name: "GL_COLOR_INDEX8_EXT", Value: uint32(32997)},
			{Name: "GL_COLOR_INDEX12_EXT", Value: uint32(32998)},
			{Name: "GL_COLOR_INDEX16_EXT", Value: uint32(32999)},
			{Name: "GL_MAX_ELEMENTS_VERTICES", Value: uint32(33000)},
			{Name: "GL_MAX_ELEMENTS_VERTICES_EXT", Value: uint32(33000)},
			{Name: "GL_MAX_ELEMENTS_INDICES_EXT", Value: uint32(33001)},
			{Name: "GL_MAX_ELEMENTS_INDICES", Value: uint32(33001)},
			{Name: "GL_PHONG_WIN", Value: uint32(33002)},
			{Name: "GL_PHONG_HINT_WIN", Value: uint32(33003)},
			{Name: "GL_FOG_SPECULAR_TEXTURE_WIN", Value: uint32(33004)},
			{Name: "GL_TEXTURE_INDEX_SIZE_EXT", Value: uint32(33005)},
			{Name: "GL_PARAMETER_BUFFER_ARB", Value: uint32(33006)},
			{Name: "GL_PARAMETER_BUFFER_BINDING_ARB", Value: uint32(33007)},
			{Name: "GL_CLIP_VOLUME_CLIPPING_HINT_EXT", Value: uint32(33008)},
			{Name: "GL_DUAL_ALPHA4_SGIS", Value: uint32(33040)},
			{Name: "GL_DUAL_ALPHA8_SGIS", Value: uint32(33041)},
			{Name: "GL_DUAL_ALPHA12_SGIS", Value: uint32(33042)},
			{Name: "GL_DUAL_ALPHA16_SGIS", Value: uint32(33043)},
			{Name: "GL_DUAL_LUMINANCE4_SGIS", Value: uint32(33044)},
			{Name: "GL_DUAL_LUMINANCE8_SGIS", Value: uint32(33045)},
			{Name: "GL_DUAL_LUMINANCE12_SGIS", Value: uint32(33046)},
			{Name: "GL_DUAL_LUMINANCE16_SGIS", Value: uint32(33047)},
			{Name: "GL_DUAL_INTENSITY4_SGIS", Value: uint32(33048)},
			{Name: "GL_DUAL_INTENSITY8_SGIS", Value: uint32(33049)},
			{Name: "GL_DUAL_INTENSITY12_SGIS", Value: uint32(33050)},
			{Name: "GL_DUAL_INTENSITY16_SGIS", Value: uint32(33051)},
			{Name: "GL_DUAL_LUMINANCE_ALPHA4_SGIS", Value: uint32(33052)},
			{Name: "GL_DUAL_LUMINANCE_ALPHA8_SGIS", Value: uint32(33053)},
			{Name: "GL_QUAD_ALPHA4_SGIS", Value: uint32(33054)},
			{Name: "GL_QUAD_ALPHA8_SGIS", Value: uint32(33055)},
			{Name: "GL_QUAD_LUMINANCE4_SGIS", Value: uint32(33056)},
			{Name: "GL_QUAD_LUMINANCE8_SGIS", Value: uint32(33057)},
			{Name: "GL_QUAD_INTENSITY4_SGIS", Value: uint32(33058)},
			{Name: "GL_QUAD_INTENSITY8_SGIS", Value: uint32(33059)},
			{Name: "GL_DUAL_TEXTURE_SELECT_SGIS", Value: uint32(33060)},
			{Name: "GL_QUAD_TEXTURE_SELECT_SGIS", Value: uint32(33061)},
			{Name: "GL_POINT_SIZE_MIN_EXT", Value: uint32(33062)},
			{Name: "GL_POINT_SIZE_MIN_ARB", Value: uint32(33062)},
			{Name: "GL_POINT_SIZE_MIN", Value: uint32(33062)},
			{Name: "GL_POINT_SIZE_MIN_SGIS", Value: uint32(33062)},
			{Name: "GL_POINT_SIZE_MAX_ARB", Value: uint32(33063)},
			{Name: "GL_POINT_SIZE_MAX_EXT", Value: uint32(33063)},
			{Name: "GL_POINT_SIZE_MAX", Value: uint32(33063)},
			{Name: "GL_POINT_SIZE_MAX_SGIS", Value: uint32(33063)},
			{Name: "GL_POINT_FADE_THRESHOLD_SIZE", Value: uint32(33064)},
			{Name: "GL_POINT_FADE_THRESHOLD_SIZE_EXT", Value: uint32(33064)},
			{Name: "GL_POINT_FADE_THRESHOLD_SIZE_ARB", Value: uint32(33064)},
			{Name: "GL_POINT_FADE_THRESHOLD_SIZE_SGIS", Value: uint32(33064)},
			{Name: "GL_POINT_DISTANCE_ATTENUATION_ARB", Value: uint32(33065)},
			{Name: "GL_POINT_DISTANCE_ATTENUATION", Value: uint32(33065)},
			{Name: "GL_DISTANCE_ATTENUATION_SGIS", Value: uint32(33065)},
			{Name: "GL_DISTANCE_ATTENUATION_EXT", Value: uint32(33065)},
			{Name: "GL_FOG_FUNC_SGIS", Value: uint32(33066)},
			{Name: "GL_FOG_FUNC_POINTS_SGIS", Value: uint32(33067)},
			{Name: "GL_MAX_FOG_FUNC_POINTS_SGIS", Value: uint32(33068)},
			{Name: "GL_CLAMP_TO_BORDER_ARB", Value: uint32(33069)},
			{Name: "GL_CLAMP_TO_BORDER", Value: uint32(33069)},
			{Name: "GL_CLAMP_TO_BORDER_EXT", Value: uint32(33069)},
			{Name: "GL_CLAMP_TO_BORDER_NV", Value: uint32(33069)},
			{Name: "GL_CLAMP_TO_BORDER_OES", Value: uint32(33069)},
			{Name: "GL_CLAMP_TO_BORDER_SGIS", Value: uint32(33069)},
			{Name: "GL_TEXTURE_MULTI_BUFFER_HINT_SGIX", Value: uint32(33070)},
			{Name: "GL_CLAMP_TO_EDGE", Value: uint32(33071)},
			{Name: "GL_CLAMP_TO_EDGE_SGIS", Value: uint32(33071)},
			{Name: "GL_PACK_SKIP_VOLUMES_SGIS", Value: uint32(33072)},
			{Name: "GL_PACK_IMAGE_DEPTH_SGIS", Value: uint32(33073)},
			{Name: "GL_UNPACK_SKIP_VOLUMES_SGIS", Value: uint32(33074)},
			{Name: "GL_UNPACK_IMAGE_DEPTH_SGIS", Value: uint32(33075)},
			{Name: "GL_TEXTURE_4D_SGIS", Value: uint32(33076)},
			{Name: "GL_PROXY_TEXTURE_4D_SGIS", Value: uint32(33077)},
			{Name: "GL_TEXTURE_4DSIZE_SGIS", Value: uint32(33078)},
			{Name: "GL_TEXTURE_WRAP_Q_SGIS", Value: uint32(33079)},
			{Name: "GL_MAX_4D_TEXTURE_SIZE_SGIS", Value: uint32(33080)},
			{Name: "GL_PIXEL_TEX_GEN_SGIX", Value: uint32(33081)},
			{Name: "GL_TEXTURE_MIN_LOD", Value: uint32(33082)},
			{Name: "GL_TEXTURE_MIN_LOD_SGIS", Value: uint32(33082)},
			{Name: "GL_TEXTURE_MAX_LOD", Value: uint32(33083)},
			{Name: "GL_TEXTURE_MAX_LOD_SGIS", Value: uint32(33083)},
			{Name: "GL_TEXTURE_BASE_LEVEL_SGIS", Value: uint32(33084)},
			{Name: "GL_TEXTURE_BASE_LEVEL", Value: uint32(33084)},
			{Name: "GL_TEXTURE_MAX_LEVEL", Value: uint32(33085)},
			{Name: "GL_TEXTURE_MAX_LEVEL_SGIS", Value: uint32(33085)},
			{Name: "GL_TEXTURE_MAX_LEVEL_APPLE", Value: uint32(33085)},
			{Name: "GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX", Value: uint32(33086)},
			{Name: "GL_PIXEL_TILE_CACHE_INCREMENT_SGIX", Value: uint32(33087)},
			{Name: "GL_PIXEL_TILE_WIDTH_SGIX", Value: uint32(33088)},
			{Name: "GL_PIXEL_TILE_HEIGHT_SGIX", Value: uint32(33089)},
			{Name: "GL_PIXEL_TILE_GRID_WIDTH_SGIX", Value: uint32(33090)},
			{Name: "GL_PIXEL_TILE_GRID_HEIGHT_SGIX", Value: uint32(33091)},
			{Name: "GL_PIXEL_TILE_GRID_DEPTH_SGIX", Value: uint32(33092)},
			{Name: "GL_PIXEL_TILE_CACHE_SIZE_SGIX", Value: uint32(33093)},
			{Name: "GL_FILTER4_SGIS", Value: uint32(33094)},
			{Name: "GL_TEXTURE_FILTER4_SIZE_SGIS", Value: uint32(33095)},
			{Name: "GL_SPRITE_SGIX", Value: uint32(33096)},
			{Name: "GL_SPRITE_MODE_SGIX", Value: uint32(33097)},
			{Name: "GL_SPRITE_AXIS_SGIX", Value: uint32(33098)},
			{Name: "GL_SPRITE_TRANSLATION_SGIX", Value: uint32(33099)},
			{Name: "GL_SPRITE_AXIAL_SGIX", Value: uint32(33100)},
			{Name: "GL_SPRITE_OBJECT_ALIGNED_SGIX", Value: uint32(33101)},
			{Name: "GL_SPRITE_EYE_ALIGNED_SGIX", Value: uint32(33102)},
			{Name: "GL_TEXTURE_4D_BINDING_SGIS", Value: uint32(33103)},
			{Name: "GL_IGNORE_BORDER_HP", Value: uint32(33104)},
			{Name: "GL_CONSTANT_BORDER", Value: uint32(33105)},
			{Name: "GL_CONSTANT_BORDER_HP", Value: uint32(33105)},
			{Name: "GL_REPLICATE_BORDER", Value: uint32(33107)},
			{Name: "GL_REPLICATE_BORDER_HP", Value: uint32(33107)},
			{Name: "GL_CONVOLUTION_BORDER_COLOR", Value: uint32(33108)},
			{Name: "GL_CONVOLUTION_BORDER_COLOR_HP", Value: uint32(33108)},
			{Name: "GL_IMAGE_SCALE_X_HP", Value: uint32(33109)},
			{Name: "GL_IMAGE_SCALE_Y_HP", Value: uint32(33110)},
			{Name: "GL_IMAGE_TRANSLATE_X_HP", Value: uint32(33111)},
			{Name: "GL_IMAGE_TRANSLATE_Y_HP", Value: uint32(33112)},
			{Name: "GL_IMAGE_ROTATE_ANGLE_HP", Value: uint32(33113)},
			{Name: "GL_IMAGE_ROTATE_ORIGIN_X_HP", Value: uint32(33114)},
			{Name: "GL_IMAGE_ROTATE_ORIGIN_Y_HP", Value: uint32(33115)},
			{Name: "GL_IMAGE_MAG_FILTER_HP", Value: uint32(33116)},
			{Name: "GL_IMAGE_MIN_FILTER_HP", Value: uint32(33117)},
			{Name: "GL_IMAGE_CUBIC_WEIGHT_HP", Value: uint32(33118)},
			{Name: "GL_CUBIC_HP", Value: uint32(33119)},
			{Name: "GL_AVERAGE_HP", Value: uint32(33120)},
			{Name: "GL_IMAGE_TRANSFORM_2D_HP", Value: uint32(33121)},
			{Name: "GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP", Value: uint32(33122)},
			{Name: "GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP", Value: uint32(33123)},
			{Name: "GL_OCCLUSION_TEST_HP", Value: uint32(33125)},
			{Name: "GL_OCCLUSION_TEST_RESULT_HP", Value: uint32(33126)},
			{Name: "GL_TEXTURE_LIGHTING_MODE_HP", Value: uint32(33127)},
			{Name: "GL_TEXTURE_POST_SPECULAR_HP", Value: uint32(33128)},
			{Name: "GL_TEXTURE_PRE_SPECULAR_HP", Value: uint32(33129)},
			{Name: "GL_LINEAR_CLIPMAP_LINEAR_SGIX", Value: uint32(33136)},
			{Name: "GL_TEXTURE_CLIPMAP_CENTER_SGIX", Value: uint32(33137)},
			{Name: "GL_TEXTURE_CLIPMAP_FRAME_SGIX", Value: uint32(33138)},
			{Name: "GL_TEXTURE_CLIPMAP_OFFSET_SGIX", Value: uint32(33139)},
			{Name: "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX", Value: uint32(33140)},
			{Name: "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX", Value: uint32(33141)},
			{Name: "GL_TEXTURE_CLIPMAP_DEPTH_SGIX", Value: uint32(33142)},
			{Name: "GL_MAX_CLIPMAP_DEPTH_SGIX", Value: uint32(33143)},
			{Name: "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX", Value: uint32(33144)},
			{Name: "GL_POST_TEXTURE_FILTER_BIAS_SGIX", Value: uint32(33145)},
			{Name: "GL_POST_TEXTURE_FILTER_SCALE_SGIX", Value: uint32(33146)},
			{Name: "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX", Value: uint32(33147)},
			{Name: "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX", Value: uint32(33148)},
			{Name: "GL_REFERENCE_PLANE_SGIX", Value: uint32(33149)},
			{Name: "GL_REFERENCE_PLANE_EQUATION_SGIX", Value: uint32(33150)},
			{Name: "GL_IR_INSTRUMENT1_SGIX", Value: uint32(33151)},
			{Name: "GL_INSTRUMENT_BUFFER_POINTER_SGIX", Value: uint32(33152)},
			{Name: "GL_INSTRUMENT_MEASUREMENTS_SGIX", Value: uint32(33153)},
			{Name: "GL_LIST_PRIORITY_SGIX", Value: uint32(33154)},
			{Name: "GL_CALLIGRAPHIC_FRAGMENT_SGIX", Value: uint32(33155)},
			{Name: "GL_PIXEL_TEX_GEN_Q_CEILING_SGIX", Value: uint32(33156)},
			{Name: "GL_PIXEL_TEX_GEN_Q_ROUND_SGIX", Value: uint32(33157)},
			{Name: "GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX", Value: uint32(33158)},
			{Name: "GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX", Value: uint32(33159)},
			{Name: "GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX", Value: uint32(33160)},
			{Name: "GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX", Value: uint32(33161)},
			{Name: "GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX", Value: uint32(33162)},
			{Name: "GL_FRAMEZOOM_SGIX", Value: uint32(33163)},
			{Name: "GL_FRAMEZOOM_FACTOR_SGIX", Value: uint32(33164)},
			{Name: "GL_MAX_FRAMEZOOM_FACTOR_SGIX", Value: uint32(33165)},
			{Name: "GL_TEXTURE_LOD_BIAS_S_SGIX", Value: uint32(33166)},
			{Name: "GL_TEXTURE_LOD_BIAS_T_SGIX", Value: uint32(33167)},
			{Name: "GL_TEXTURE_LOD_BIAS_R_SGIX", Value: uint32(33168)},
			{Name: "GL_GENERATE_MIPMAP_SGIS", Value: uint32(33169)},
			{Name: "GL_GENERATE_MIPMAP", Value: uint32(33169)},
			{Name: "GL_GENERATE_MIPMAP_HINT", Value: uint32(33170)},
			{Name: "GL_GENERATE_MIPMAP_HINT_SGIS", Value: uint32(33170)},
			{Name: "GL_GEOMETRY_DEFORMATION_SGIX", Value: uint32(33172)},
			{Name: "GL_TEXTURE_DEFORMATION_SGIX", Value: uint32(33173)},
			{Name: "GL_DEFORMATIONS_MASK_SGIX", Value: uint32(33174)},
			{Name: "GL_MAX_DEFORMATION_ORDER_SGIX", Value: uint32(33175)},
			{Name: "GL_FOG_OFFSET_SGIX", Value: uint32(33176)},
			{Name: "GL_FOG_OFFSET_VALUE_SGIX", Value: uint32(33177)},
			{Name: "GL_TEXTURE_COMPARE_SGIX", Value: uint32(33178)},
			{Name: "GL_TEXTURE_COMPARE_OPERATOR_SGIX", Value: uint32(33179)},
			{Name: "GL_TEXTURE_LEQUAL_R_SGIX", Value: uint32(33180)},
			{Name: "GL_TEXTURE_GEQUAL_R_SGIX", Value: uint32(33181)},
			{Name: "GL_DEPTH_COMPONENT16_SGIX", Value: uint32(33189)},
			{Name: "GL_DEPTH_COMPONENT16_ARB", Value: uint32(33189)},
			{Name: "GL_DEPTH_COMPONENT16", Value: uint32(33189)},
			{Name: "GL_DEPTH_COMPONENT16_OES", Value: uint32(33189)},
			{Name: "GL_DEPTH_COMPONENT24_OES", Value: uint32(33190)},
			{Name: "GL_DEPTH_COMPONENT24_SGIX", Value: uint32(33190)},
			{Name: "GL_DEPTH_COMPONENT24", Value: uint32(33190)},
			{Name: "GL_DEPTH_COMPONENT24_ARB", Value: uint32(33190)},
			{Name: "GL_DEPTH_COMPONENT32_SGIX", Value: uint32(33191)},
			{Name: "GL_DEPTH_COMPONENT32_OES", Value: uint32(33191)},
			{Name: "GL_DEPTH_COMPONENT32_ARB", Value: uint32(33191)},
			{Name: "GL_DEPTH_COMPONENT32", Value: uint32(33191)},
			{Name: "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT", Value: uint32(33192)},
			{Name: "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT", Value: uint32(33193)},
			{Name: "GL_CULL_VERTEX_EXT", Value: uint32(33194)},
			{Name: "GL_CULL_VERTEX_EYE_POSITION_EXT", Value: uint32(33195)},
			{Name: "GL_CULL_VERTEX_OBJECT_POSITION_EXT", Value: uint32(33196)},
			{Name: "GL_IUI_V2F_EXT", Value: uint32(33197)},
			{Name: "GL_IUI_V3F_EXT", Value: uint32(33198)},
			{Name: "GL_IUI_N3F_V2F_EXT", Value: uint32(33199)},
			{Name: "GL_IUI_N3F_V3F_EXT", Value: uint32(33200)},
			{Name: "GL_T2F_IUI_V2F_EXT", Value: uint32(33201)},
			{Name: "GL_T2F_IUI_V3F_EXT", Value: uint32(33202)},
			{Name: "GL_T2F_IUI_N3F_V2F_EXT", Value: uint32(33203)},
			{Name: "GL_T2F_IUI_N3F_V3F_EXT", Value: uint32(33204)},
			{Name: "GL_INDEX_TEST_EXT", Value: uint32(33205)},
			{Name: "GL_INDEX_TEST_FUNC_EXT", Value: uint32(33206)},
			{Name: "GL_INDEX_TEST_REF_EXT", Value: uint32(33207)},
			{Name: "GL_INDEX_MATERIAL_EXT", Value: uint32(33208)},
			{Name: "GL_INDEX_MATERIAL_PARAMETER_EXT", Value: uint32(33209)},
			{Name: "GL_INDEX_MATERIAL_FACE_EXT", Value: uint32(33210)},
			{Name: "GL_YCRCB_422_SGIX", Value: uint32(33211)},
			{Name: "GL_YCRCB_444_SGIX", Value: uint32(33212)},
			{Name: "GL_WRAP_BORDER_SUN", Value: uint32(33236)},
			{Name: "GL_UNPACK_CONSTANT_DATA_SUNX", Value: uint32(33237)},
			{Name: "GL_TEXTURE_CONSTANT_DATA_SUNX", Value: uint32(33238)},
			{Name: "GL_TRIANGLE_LIST_SUN", Value: uint32(33239)},
			{Name: "GL_REPLACEMENT_CODE_SUN", Value: uint32(33240)},
			{Name: "GL_GLOBAL_ALPHA_SUN", Value: uint32(33241)},
			{Name: "GL_GLOBAL_ALPHA_FACTOR_SUN", Value: uint32(33242)},
			{Name: "GL_TEXTURE_COLOR_WRITEMASK_SGIS", Value: uint32(33263)},
			{Name: "GL_EYE_DISTANCE_TO_POINT_SGIS", Value: uint32(33264)},
			{Name: "GL_OBJECT_DISTANCE_TO_POINT_SGIS", Value: uint32(33265)},
			{Name: "GL_EYE_DISTANCE_TO_LINE_SGIS", Value: uint32(33266)},
			{Name: "GL_OBJECT_DISTANCE_TO_LINE_SGIS", Value: uint32(33267)},
			{Name: "GL_EYE_POINT_SGIS", Value: uint32(33268)},
			{Name: "GL_OBJECT_POINT_SGIS", Value: uint32(33269)},
			{Name: "GL_EYE_LINE_SGIS", Value: uint32(33270)},
			{Name: "GL_OBJECT_LINE_SGIS", Value: uint32(33271)},
			{Name: "GL_LIGHT_MODEL_COLOR_CONTROL", Value: uint32(33272)},
			{Name: "GL_LIGHT_MODEL_COLOR_CONTROL_EXT", Value: uint32(33272)},
			{Name: "GL_SINGLE_COLOR", Value: uint32(33273)},
			{Name: "GL_SINGLE_COLOR_EXT", Value: uint32(33273)},
			{Name: "GL_SEPARATE_SPECULAR_COLOR", Value: uint32(33274)},
			{Name: "GL_SEPARATE_SPECULAR_COLOR_EXT", Value: uint32(33274)},
			{Name: "GL_SHARED_TEXTURE_PALETTE_EXT", Value: uint32(33275)},
			{Name: "GL_TEXT_FRAGMENT_SHADER_ATI", Value: uint32(33280)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", Value: uint32(33296)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT", Value: uint32(33296)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", Value: uint32(33297)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT", Value: uint32(33297)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE", Value: uint32(33298)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", Value: uint32(33299)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", Value: uint32(33300)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", Value: uint32(33301)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", Value: uint32(33302)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", Value: uint32(33303)},
			{Name: "GL_FRAMEBUFFER_DEFAULT", Value: uint32(33304)},
			{Name: "GL_FRAMEBUFFER_UNDEFINED", Value: uint32(33305)},
			{Name: "GL_FRAMEBUFFER_UNDEFINED_OES", Value: uint32(33305)},
			{Name: "GL_DEPTH_STENCIL_ATTACHMENT", Value: uint32(33306)},
			{Name: "GL_MAJOR_VERSION", Value: uint32(33307)},
			{Name: "GL_MINOR_VERSION", Value: uint32(33308)},
			{Name: "GL_NUM_EXTENSIONS", Value: uint32(33309)},
			{Name: "GL_CONTEXT_FLAGS", Value: uint32(33310)},
			{Name: "GL_BUFFER_IMMUTABLE_STORAGE_EXT", Value: uint32(33311)},
			{Name: "GL_BUFFER_IMMUTABLE_STORAGE", Value: uint32(33311)},
			{Name: "GL_BUFFER_STORAGE_FLAGS_EXT", Value: uint32(33312)},
			{Name: "GL_BUFFER_STORAGE_FLAGS", Value: uint32(33312)},
			{Name: "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED", Value: uint32(33313)},
			{Name: "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES", Value: uint32(33313)},
			{Name: "GL_INDEX", Value: uint32(33314)},
			{Name: "GL_COMPRESSED_RED", Value: uint32(33317)},
			{Name: "GL_COMPRESSED_RG", Value: uint32(33318)},
			{Name: "GL_RG", Value: uint32(33319)},
			{Name: "GL_RG_EXT", Value: uint32(33319)},
			{Name: "GL_RG_INTEGER", Value: uint32(33320)},
			{Name: "GL_R8", Value: uint32(33321)},
			{Name: "GL_R8_EXT", Value: uint32(33321)},
			{Name: "GL_R16", Value: uint32(33322)},
			{Name: "GL_R16_EXT", Value: uint32(33322)},
			{Name: "GL_RG8_EXT", Value: uint32(33323)},
			{Name: "GL_RG8", Value: uint32(33323)},
			{Name: "GL_RG16_EXT", Value: uint32(33324)},
			{Name: "GL_RG16", Value: uint32(33324)},
			{Name: "GL_R16F_EXT", Value: uint32(33325)},
			{Name: "GL_R16F", Value: uint32(33325)},
			{Name: "GL_R32F_EXT", Value: uint32(33326)},
			{Name: "GL_R32F", Value: uint32(33326)},
			{Name: "GL_RG16F", Value: uint32(33327)},
			{Name: "GL_RG16F_EXT", Value: uint32(33327)},
			{Name: "GL_RG32F_EXT", Value: uint32(33328)},
			{Name: "GL_RG32F", Value: uint32(33328)},
			{Name: "GL_R8I", Value: uint32(33329)},
			{Name: "GL_R8UI", Value: uint32(33330)},
			{Name: "GL_R16I", Value: uint32(33331)},
			{Name: "GL_R16UI", Value: uint32(33332)},
			{Name: "GL_R32I", Value: uint32(33333)},
			{Name: "GL_R32UI", Value: uint32(33334)},
			{Name: "GL_RG8I", Value: uint32(33335)},
			{Name: "GL_RG8UI", Value: uint32(33336)},
			{Name: "GL_RG16I", Value: uint32(33337)},
			{Name: "GL_RG16UI", Value: uint32(33338)},
			{Name: "GL_RG32I", Value: uint32(33339)},
			{Name: "GL_RG32UI", Value: uint32(33340)},
			{Name: "GL_SYNC_CL_EVENT_ARB", Value: uint32(33344)},
			{Name: "GL_SYNC_CL_EVENT_COMPLETE_ARB", Value: uint32(33345)},
			{Name: "GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR", Value: uint32(33346)},
			{Name: "GL_DEBUG_OUTPUT_SYNCHRONOUS", Value: uint32(33346)},
			{Name: "GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB", Value: uint32(33346)},
			{Name: "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR", Value: uint32(33347)},
			{Name: "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH", Value: uint32(33347)},
			{Name: "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB", Value: uint32(33347)},
			{Name: "GL_DEBUG_CALLBACK_FUNCTION_KHR", Value: uint32(33348)},
			{Name: "GL_DEBUG_CALLBACK_FUNCTION", Value: uint32(33348)},
			{Name: "GL_DEBUG_CALLBACK_FUNCTION_ARB", Value: uint32(33348)},
			{Name: "GL_DEBUG_CALLBACK_USER_PARAM_ARB", Value: uint32(33349)},
			{Name: "GL_DEBUG_CALLBACK_USER_PARAM", Value: uint32(33349)},
			{Name: "GL_DEBUG_CALLBACK_USER_PARAM_KHR", Value: uint32(33349)},
			{Name: "GL_DEBUG_SOURCE_API", Value: uint32(33350)},
			{Name: "GL_DEBUG_SOURCE_API_KHR", Value: uint32(33350)},
			{Name: "GL_DEBUG_SOURCE_API_ARB", Value: uint32(33350)},
			{Name: "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR", Value: uint32(33351)},
			{Name: "GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB", Value: uint32(33351)},
			{Name: "GL_DEBUG_SOURCE_WINDOW_SYSTEM", Value: uint32(33351)},
			{Name: "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR", Value: uint32(33352)},
			{Name: "GL_DEBUG_SOURCE_SHADER_COMPILER_ARB", Value: uint32(33352)},
			{Name: "GL_DEBUG_SOURCE_SHADER_COMPILER", Value: uint32(33352)},
			{Name: "GL_DEBUG_SOURCE_THIRD_PARTY_ARB", Value: uint32(33353)},
			{Name: "GL_DEBUG_SOURCE_THIRD_PARTY", Value: uint32(33353)},
			{Name: "GL_DEBUG_SOURCE_THIRD_PARTY_KHR", Value: uint32(33353)},
			{Name: "GL_DEBUG_SOURCE_APPLICATION_KHR", Value: uint32(33354)},
			{Name: "GL_DEBUG_SOURCE_APPLICATION", Value: uint32(33354)},
			{Name: "GL_DEBUG_SOURCE_APPLICATION_ARB", Value: uint32(33354)},
			{Name: "GL_DEBUG_SOURCE_OTHER_ARB", Value: uint32(33355)},
			{Name: "GL_DEBUG_SOURCE_OTHER", Value: uint32(33355)},
			{Name: "GL_DEBUG_SOURCE_OTHER_KHR", Value: uint32(33355)},
			{Name: "GL_DEBUG_TYPE_ERROR_ARB", Value: uint32(33356)},
			{Name: "GL_DEBUG_TYPE_ERROR", Value: uint32(33356)},
			{Name: "GL_DEBUG_TYPE_ERROR_KHR", Value: uint32(33356)},
			{Name: "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB", Value: uint32(33357)},
			{Name: "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR", Value: uint32(33357)},
			{Name: "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR", Value: uint32(33357)},
			{Name: "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB", Value: uint32(33358)},
			{Name: "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR", Value: uint32(33358)},
			{Name: "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR", Value: uint32(33358)},
			{Name: "GL_DEBUG_TYPE_PORTABILITY_ARB", Value: uint32(33359)},
			{Name: "GL_DEBUG_TYPE_PORTABILITY", Value: uint32(33359)},
			{Name: "GL_DEBUG_TYPE_PORTABILITY_KHR", Value: uint32(33359)},
			{Name: "GL_DEBUG_TYPE_PERFORMANCE", Value: uint32(33360)},
			{Name: "GL_DEBUG_TYPE_PERFORMANCE_KHR", Value: uint32(33360)},
			{Name: "GL_DEBUG_TYPE_PERFORMANCE_ARB", Value: uint32(33360)},
			{Name: "GL_DEBUG_TYPE_OTHER_ARB", Value: uint32(33361)},
			{Name: "GL_DEBUG_TYPE_OTHER", Value: uint32(33361)},
			{Name: "GL_DEBUG_TYPE_OTHER_KHR", Value: uint32(33361)},
			{Name: "GL_LOSE_CONTEXT_ON_RESET_ARB", Value: uint32(33362)},
			{Name: "GL_LOSE_CONTEXT_ON_RESET", Value: uint32(33362)},
			{Name: "GL_LOSE_CONTEXT_ON_RESET_EXT", Value: uint32(33362)},
			{Name: "GL_LOSE_CONTEXT_ON_RESET_KHR", Value: uint32(33362)},
			{Name: "GL_GUILTY_CONTEXT_RESET_EXT", Value: uint32(33363)},
			{Name: "GL_GUILTY_CONTEXT_RESET_ARB", Value: uint32(33363)},
			{Name: "GL_GUILTY_CONTEXT_RESET_KHR", Value: uint32(33363)},
			{Name: "GL_GUILTY_CONTEXT_RESET", Value: uint32(33363)},
			{Name: "GL_INNOCENT_CONTEXT_RESET_EXT", Value: uint32(33364)},
			{Name: "GL_INNOCENT_CONTEXT_RESET_KHR", Value: uint32(33364)},
			{Name: "GL_INNOCENT_CONTEXT_RESET_ARB", Value: uint32(33364)},
			{Name: "GL_INNOCENT_CONTEXT_RESET", Value: uint32(33364)},
			{Name: "GL_UNKNOWN_CONTEXT_RESET", Value: uint32(33365)},
			{Name: "GL_UNKNOWN_CONTEXT_RESET_KHR", Value: uint32(33365)},
			{Name: "GL_UNKNOWN_CONTEXT_RESET_ARB", Value: uint32(33365)},
			{Name: "GL_UNKNOWN_CONTEXT_RESET_EXT", Value: uint32(33365)},
			{Name: "GL_RESET_NOTIFICATION_STRATEGY_KHR", Value: uint32(33366)},
			{Name: "GL_RESET_NOTIFICATION_STRATEGY", Value: uint32(33366)},
			{Name: "GL_RESET_NOTIFICATION_STRATEGY_EXT", Value: uint32(33366)},
			{Name: "GL_RESET_NOTIFICATION_STRATEGY_ARB", Value: uint32(33366)},
			{Name: "GL_PROGRAM_BINARY_RETRIEVABLE_HINT", Value: uint32(33367)},
			{Name: "GL_PROGRAM_SEPARABLE_EXT", Value: uint32(33368)},
			{Name: "GL_PROGRAM_SEPARABLE", Value: uint32(33368)},
			{Name: "GL_ACTIVE_PROGRAM", Value: uint32(33369)},
			{Name: "GL_ACTIVE_PROGRAM_EXT", Value: uint32(33369)},
			{Name: "GL_PROGRAM_PIPELINE_BINDING", Value: uint32(33370)},
			{Name: "GL_PROGRAM_PIPELINE_BINDING_EXT", Value: uint32(33370)},
			{Name: "GL_MAX_VIEWPORTS_NV", Value: uint32(33371)},
			{Name: "GL_MAX_VIEWPORTS", Value: uint32(33371)},
			{Name: "GL_VIEWPORT_SUBPIXEL_BITS_EXT", Value: uint32(33372)},
			{Name: "GL_VIEWPORT_SUBPIXEL_BITS_NV", Value: uint32(33372)},
			{Name: "GL_VIEWPORT_SUBPIXEL_BITS", Value: uint32(33372)},
			{Name: "GL_VIEWPORT_BOUNDS_RANGE", Value: uint32(33373)},
			{Name: "GL_VIEWPORT_BOUNDS_RANGE_NV", Value: uint32(33373)},
			{Name: "GL_VIEWPORT_BOUNDS_RANGE_EXT", Value: uint32(33373)},
			{Name: "GL_LAYER_PROVOKING_VERTEX", Value: uint32(33374)},
			{Name: "GL_LAYER_PROVOKING_VERTEX_EXT", Value: uint32(33374)},
			{Name: "GL_LAYER_PROVOKING_VERTEX_OES", Value: uint32(33374)},
			{Name: "GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV", Value: uint32(33375)},
			{Name: "GL_VIEWPORT_INDEX_PROVOKING_VERTEX_EXT", Value: uint32(33375)},
			{Name: "GL_VIEWPORT_INDEX_PROVOKING_VERTEX", Value: uint32(33375)},
			{Name: "GL_UNDEFINED_VERTEX", Value: uint32(33376)},
			{Name: "GL_UNDEFINED_VERTEX_EXT", Value: uint32(33376)},
			{Name: "GL_UNDEFINED_VERTEX_OES", Value: uint32(33376)},
			{Name: "GL_NO_RESET_NOTIFICATION", Value: uint32(33377)},
			{Name: "GL_NO_RESET_NOTIFICATION_ARB", Value: uint32(33377)},
			{Name: "GL_NO_RESET_NOTIFICATION_EXT", Value: uint32(33377)},
			{Name: "GL_NO_RESET_NOTIFICATION_KHR", Value: uint32(33377)},
			{Name: "GL_MAX_COMPUTE_SHARED_MEMORY_SIZE", Value: uint32(33378)},
			{Name: "GL_MAX_COMPUTE_UNIFORM_COMPONENTS", Value: uint32(33379)},
			{Name: "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS", Value: uint32(33380)},
			{Name: "GL_MAX_COMPUTE_ATOMIC_COUNTERS", Value: uint32(33381)},
			{Name: "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS", Value: uint32(33382)},
			{Name: "GL_COMPUTE_WORK_GROUP_SIZE", Value: uint32(33383)},
			{Name: "GL_DEBUG_TYPE_MARKER_KHR", Value: uint32(33384)},
			{Name: "GL_DEBUG_TYPE_MARKER", Value: uint32(33384)},
			{Name: "GL_DEBUG_TYPE_PUSH_GROUP_KHR", Value: uint32(33385)},
			{Name: "GL_DEBUG_TYPE_PUSH_GROUP", Value: uint32(33385)},
			{Name: "GL_DEBUG_TYPE_POP_GROUP_KHR", Value: uint32(33386)},
			{Name: "GL_DEBUG_TYPE_POP_GROUP", Value: uint32(33386)},
			{Name: "GL_DEBUG_SEVERITY_NOTIFICATION_KHR", Value: uint32(33387)},
			{Name: "GL_DEBUG_SEVERITY_NOTIFICATION", Value: uint32(33387)},
			{Name: "GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR", Value: uint32(33388)},
			{Name: "GL_MAX_DEBUG_GROUP_STACK_DEPTH", Value: uint32(33388)},
			{Name: "GL_DEBUG_GROUP_STACK_DEPTH_KHR", Value: uint32(33389)},
			{Name: "GL_DEBUG_GROUP_STACK_DEPTH", Value: uint32(33389)},
			{Name: "GL_MAX_UNIFORM_LOCATIONS", Value: uint32(33390)},
			{Name: "GL_INTERNALFORMAT_SUPPORTED", Value: uint32(33391)},
			{Name: "GL_INTERNALFORMAT_PREFERRED", Value: uint32(33392)},
			{Name: "GL_INTERNALFORMAT_RED_SIZE", Value: uint32(33393)},
			{Name: "GL_INTERNALFORMAT_GREEN_SIZE", Value: uint32(33394)},
			{Name: "GL_INTERNALFORMAT_BLUE_SIZE", Value: uint32(33395)},
			{Name: "GL_INTERNALFORMAT_ALPHA_SIZE", Value: uint32(33396)},
			{Name: "GL_INTERNALFORMAT_DEPTH_SIZE", Value: uint32(33397)},
			{Name: "GL_INTERNALFORMAT_STENCIL_SIZE", Value: uint32(33398)},
			{Name: "GL_INTERNALFORMAT_SHARED_SIZE", Value: uint32(33399)},
			{Name: "GL_INTERNALFORMAT_RED_TYPE", Value: uint32(33400)},
			{Name: "GL_INTERNALFORMAT_GREEN_TYPE", Value: uint32(33401)},
			{Name: "GL_INTERNALFORMAT_BLUE_TYPE", Value: uint32(33402)},
			{Name: "GL_INTERNALFORMAT_ALPHA_TYPE", Value: uint32(33403)},
			{Name: "GL_INTERNALFORMAT_DEPTH_TYPE", Value: uint32(33404)},
			{Name: "GL_INTERNALFORMAT_STENCIL_TYPE", Value: uint32(33405)},
			{Name: "GL_MAX_WIDTH", Value: uint32(33406)},
			{Name: "GL_MAX_HEIGHT", Value: uint32(33407)},
			{Name: "GL_MAX_DEPTH", Value: uint32(33408)},
			{Name: "GL_MAX_LAYERS", Value: uint32(33409)},
			{Name: "GL_MAX_COMBINED_DIMENSIONS", Value: uint32(33410)},
			{Name: "GL_COLOR_COMPONENTS", Value: uint32(33411)},
			{Name: "GL_DEPTH_COMPONENTS", Value: uint32(33412)},
			{Name: "GL_STENCIL_COMPONENTS", Value: uint32(33413)},
			{Name: "GL_COLOR_RENDERABLE", Value: uint32(33414)},
			{Name: "GL_DEPTH_RENDERABLE", Value: uint32(33415)},
			{Name: "GL_STENCIL_RENDERABLE", Value: uint32(33416)},
			{Name: "GL_FRAMEBUFFER_RENDERABLE", Value: uint32(33417)},
			{Name: "GL_FRAMEBUFFER_RENDERABLE_LAYERED", Value: uint32(33418)},
			{Name: "GL_FRAMEBUFFER_BLEND", Value: uint32(33419)},
			{Name: "GL_READ_PIXELS", Value: uint32(33420)},
			{Name: "GL_READ_PIXELS_FORMAT", Value: uint32(33421)},
			{Name: "GL_READ_PIXELS_TYPE", Value: uint32(33422)},
			{Name: "GL_TEXTURE_IMAGE_FORMAT", Value: uint32(33423)},
			{Name: "GL_TEXTURE_IMAGE_TYPE", Value: uint32(33424)},
			{Name: "GL_GET_TEXTURE_IMAGE_FORMAT", Value: uint32(33425)},
			{Name: "GL_GET_TEXTURE_IMAGE_TYPE", Value: uint32(33426)},
			{Name: "GL_MIPMAP", Value: uint32(33427)},
			{Name: "GL_MANUAL_GENERATE_MIPMAP", Value: uint32(33428)},
			{Name: "GL_AUTO_GENERATE_MIPMAP", Value: uint32(33429)},
			{Name: "GL_COLOR_ENCODING", Value: uint32(33430)},
			{Name: "GL_SRGB_READ", Value: uint32(33431)},
			{Name: "GL_SRGB_WRITE", Value: uint32(33432)},
			{Name: "GL_SRGB_DECODE_ARB", Value: uint32(33433)},
			{Name: "GL_FILTER", Value: uint32(33434)},
			{Name: "GL_VERTEX_TEXTURE", Value: uint32(33435)},
			{Name: "GL_TESS_CONTROL_TEXTURE", Value: uint32(33436)},
			{Name: "GL_TESS_EVALUATION_TEXTURE", Value: uint32(33437)},
			{Name: "GL_GEOMETRY_TEXTURE", Value: uint32(33438)},
			{Name: "GL_FRAGMENT_TEXTURE", Value: uint32(33439)},
			{Name: "GL_COMPUTE_TEXTURE", Value: uint32(33440)},
			{Name: "GL_TEXTURE_SHADOW", Value: uint32(33441)},
			{Name: "GL_TEXTURE_GATHER", Value: uint32(33442)},
			{Name: "GL_TEXTURE_GATHER_SHADOW", Value: uint32(33443)},
			{Name: "GL_SHADER_IMAGE_LOAD", Value: uint32(33444)},
			{Name: "GL_SHADER_IMAGE_STORE", Value: uint32(33445)},
			{Name: "GL_SHADER_IMAGE_ATOMIC", Value: uint32(33446)},
			{Name: "GL_IMAGE_TEXEL_SIZE", Value: uint32(33447)},
			{Name: "GL_IMAGE_COMPATIBILITY_CLASS", Value: uint32(33448)},
			{Name: "GL_IMAGE_PIXEL_FORMAT", Value: uint32(33449)},
			{Name: "GL_IMAGE_PIXEL_TYPE", Value: uint32(33450)},
			{Name: "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST", Value: uint32(33452)},
			{Name: "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST", Value: uint32(33453)},
			{Name: "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE", Value: uint32(33454)},
			{Name: "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE", Value: uint32(33455)},
			{Name: "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH", Value: uint32(33457)},
			{Name: "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT", Value: uint32(33458)},
			{Name: "GL_TEXTURE_COMPRESSED_BLOCK_SIZE", Value: uint32(33459)},
			{Name: "GL_CLEAR_BUFFER", Value: uint32(33460)},
			{Name: "GL_TEXTURE_VIEW", Value: uint32(33461)},
			{Name: "GL_VIEW_COMPATIBILITY_CLASS", Value: uint32(33462)},
			{Name: "GL_FULL_SUPPORT", Value: uint32(33463)},
			{Name: "GL_CAVEAT_SUPPORT", Value: uint32(33464)},
			{Name: "GL_IMAGE_CLASS_4_X_32", Value: uint32(33465)},
			{Name: "GL_IMAGE_CLASS_2_X_32", Value: uint32(33466)},
			{Name: "GL_IMAGE_CLASS_1_X_32", Value: uint32(33467)},
			{Name: "GL_IMAGE_CLASS_4_X_16", Value: uint32(33468)},
			{Name: "GL_IMAGE_CLASS_2_X_16", Value: uint32(33469)},
			{Name: "GL_IMAGE_CLASS_1_X_16", Value: uint32(33470)},
			{Name: "GL_IMAGE_CLASS_4_X_8", Value: uint32(33471)},
			{Name: "GL_IMAGE_CLASS_2_X_8", Value: uint32(33472)},
			{Name: "GL_IMAGE_CLASS_1_X_8", Value: uint32(33473)},
			{Name: "GL_IMAGE_CLASS_11_11_10", Value: uint32(33474)},
			{Name: "GL_IMAGE_CLASS_10_10_10_2", Value: uint32(33475)},
			{Name: "GL_VIEW_CLASS_128_BITS", Value: uint32(33476)},
			{Name: "GL_VIEW_CLASS_96_BITS", Value: uint32(33477)},
			{Name: "GL_VIEW_CLASS_64_BITS", Value: uint32(33478)},
			{Name: "GL_VIEW_CLASS_48_BITS", Value: uint32(33479)},
			{Name: "GL_VIEW_CLASS_32_BITS", Value: uint32(33480)},
			{Name: "GL_VIEW_CLASS_24_BITS", Value: uint32(33481)},
			{Name: "GL_VIEW_CLASS_16_BITS", Value: uint32(33482)},
			{Name: "GL_VIEW_CLASS_8_BITS", Value: uint32(33483)},
			{Name: "GL_VIEW_CLASS_S3TC_DXT1_RGB", Value: uint32(33484)},
			{Name: "GL_VIEW_CLASS_S3TC_DXT1_RGBA", Value: uint32(33485)},
			{Name: "GL_VIEW_CLASS_S3TC_DXT3_RGBA", Value: uint32(33486)},
			{Name: "GL_VIEW_CLASS_S3TC_DXT5_RGBA", Value: uint32(33487)},
			{Name: "GL_VIEW_CLASS_RGTC1_RED", Value: uint32(33488)},
			{Name: "GL_VIEW_CLASS_RGTC2_RG", Value: uint32(33489)},
			{Name: "GL_VIEW_CLASS_BPTC_UNORM", Value: uint32(33490)},
			{Name: "GL_VIEW_CLASS_BPTC_FLOAT", Value: uint32(33491)},
			{Name: "GL_VERTEX_ATTRIB_BINDING", Value: uint32(33492)},
			{Name: "GL_VERTEX_ATTRIB_RELATIVE_OFFSET", Value: uint32(33493)},
			{Name: "GL_VERTEX_BINDING_DIVISOR", Value: uint32(33494)},
			{Name: "GL_VERTEX_BINDING_OFFSET", Value: uint32(33495)},
			{Name: "GL_VERTEX_BINDING_STRIDE", Value: uint32(33496)},
			{Name: "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET", Value: uint32(33497)},
			{Name: "GL_MAX_VERTEX_ATTRIB_BINDINGS", Value: uint32(33498)},
			{Name: "GL_TEXTURE_VIEW_MIN_LEVEL_OES", Value: uint32(33499)},
			{Name: "GL_TEXTURE_VIEW_MIN_LEVEL_EXT", Value: uint32(33499)},
			{Name: "GL_TEXTURE_VIEW_MIN_LEVEL", Value: uint32(33499)},
			{Name: "GL_TEXTURE_VIEW_NUM_LEVELS_OES", Value: uint32(33500)},
			{Name: "GL_TEXTURE_VIEW_NUM_LEVELS", Value: uint32(33500)},
			{Name: "GL_TEXTURE_VIEW_NUM_LEVELS_EXT", Value: uint32(33500)},
			{Name: "GL_TEXTURE_VIEW_MIN_LAYER_EXT", Value: uint32(33501)},
			{Name: "GL_TEXTURE_VIEW_MIN_LAYER", Value: uint32(33501)},
			{Name: "GL_TEXTURE_VIEW_MIN_LAYER_OES", Value: uint32(33501)},
			{Name: "GL_TEXTURE_VIEW_NUM_LAYERS", Value: uint32(33502)},
			{Name: "GL_TEXTURE_VIEW_NUM_LAYERS_EXT", Value: uint32(33502)},
			{Name: "GL_TEXTURE_VIEW_NUM_LAYERS_OES", Value: uint32(33502)},
			{Name: "GL_TEXTURE_IMMUTABLE_LEVELS", Value: uint32(33503)},
			{Name: "GL_BUFFER", Value: uint32(33504)},
			{Name: "GL_BUFFER_KHR", Value: uint32(33504)},
			{Name: "GL_SHADER_KHR", Value: uint32(33505)},
			{Name: "GL_SHADER", Value: uint32(33505)},
			{Name: "GL_PROGRAM", Value: uint32(33506)},
			{Name: "GL_PROGRAM_KHR", Value: uint32(33506)},
			{Name: "GL_QUERY", Value: uint32(33507)},
			{Name: "GL_QUERY_KHR", Value: uint32(33507)},
			{Name: "GL_PROGRAM_PIPELINE_KHR", Value: uint32(33508)},
			{Name: "GL_PROGRAM_PIPELINE", Value: uint32(33508)},
			{Name: "GL_MAX_VERTEX_ATTRIB_STRIDE", Value: uint32(33509)},
			{Name: "GL_SAMPLER", Value: uint32(33510)},
			{Name: "GL_SAMPLER_KHR", Value: uint32(33510)},
			{Name: "GL_DISPLAY_LIST", Value: uint32(33511)},
			{Name: "GL_MAX_LABEL_LENGTH", Value: uint32(33512)},
			{Name: "GL_MAX_LABEL_LENGTH_KHR", Value: uint32(33512)},
			{Name: "GL_NUM_SHADING_LANGUAGE_VERSIONS", Value: uint32(33513)},
			{Name: "GL_QUERY_TARGET", Value: uint32(33514)},
			{Name: "GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB", Value: uint32(33516)},
			{Name: "GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB", Value: uint32(33517)},
			{Name: "GL_VERTICES_SUBMITTED_ARB", Value: uint32(33518)},
			{Name: "GL_PRIMITIVES_SUBMITTED_ARB", Value: uint32(33519)},
			{Name: "GL_VERTEX_SHADER_INVOCATIONS_ARB", Value: uint32(33520)},
			{Name: "GL_TESS_CONTROL_SHADER_PATCHES_ARB", Value: uint32(33521)},
			{Name: "GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB", Value: uint32(33522)},
			{Name: "GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB", Value: uint32(33523)},
			{Name: "GL_FRAGMENT_SHADER_INVOCATIONS_ARB", Value: uint32(33524)},
			{Name: "GL_COMPUTE_SHADER_INVOCATIONS_ARB", Value: uint32(33525)},
			{Name: "GL_CLIPPING_INPUT_PRIMITIVES_ARB", Value: uint32(33526)},
			{Name: "GL_CLIPPING_OUTPUT_PRIMITIVES_ARB", Value: uint32(33527)},
			{Name: "GL_SPARSE_BUFFER_PAGE_SIZE_ARB", Value: uint32(33528)},
			{Name: "GL_MAX_CULL_DISTANCES", Value: uint32(33529)},
			{Name: "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES", Value: uint32(33530)},
			{Name: "GL_CONTEXT_RELEASE_BEHAVIOR", Value: uint32(33531)},
			{Name: "GL_CONTEXT_RELEASE_BEHAVIOR_KHR", Value: uint32(33531)},
			{Name: "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR", Value: uint32(33532)},
			{Name: "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH", Value: uint32(33532)},
			{Name: "GL_DEPTH_PASS_INSTRUMENT_SGIX", Value: uint32(33552)},
			{Name: "GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX", Value: uint32(33553)},
			{Name: "GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX", Value: uint32(33554)},
			{Name: "GL_FRAGMENTS_INSTRUMENT_SGIX", Value: uint32(33555)},
			{Name: "GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX", Value: uint32(33556)},
			{Name: "GL_FRAGMENTS_INSTRUMENT_MAX_SGIX", Value: uint32(33557)},
			{Name: "GL_CONVOLUTION_HINT_SGIX", Value: uint32(33558)},
			{Name: "GL_YCRCB_SGIX", Value: uint32(33560)},
			{Name: "GL_YCRCBA_SGIX", Value: uint32(33561)},
			{Name: "GL_UNPACK_COMPRESSED_SIZE_SGIX", Value: uint32(33562)},
			{Name: "GL_PACK_MAX_COMPRESSED_SIZE_SGIX", Value: uint32(33563)},
			{Name: "GL_PACK_COMPRESSED_SIZE_SGIX", Value: uint32(33564)},
			{Name: "GL_SLIM8U_SGIX", Value: uint32(33565)},
			{Name: "GL_SLIM10U_SGIX", Value: uint32(33566)},
			{Name: "GL_SLIM12S_SGIX", Value: uint32(33567)},
			{Name: "GL_ALPHA_MIN_SGIX", Value: uint32(33568)},
			{Name: "GL_ALPHA_MAX_SGIX", Value: uint32(33569)},
			{Name: "GL_SCALEBIAS_HINT_SGIX", Value: uint32(33570)},
			{Name: "GL_ASYNC_MARKER_SGIX", Value: uint32(33577)},
			{Name: "GL_PIXEL_TEX_GEN_MODE_SGIX", Value: uint32(33579)},
			{Name: "GL_ASYNC_HISTOGRAM_SGIX", Value: uint32(33580)},
			{Name: "GL_MAX_ASYNC_HISTOGRAM_SGIX", Value: uint32(33581)},
			{Name: "GL_PIXEL_TRANSFORM_2D_EXT", Value: uint32(33584)},
			{Name: "GL_PIXEL_MAG_FILTER_EXT", Value: uint32(33585)},
			{Name: "GL_PIXEL_MIN_FILTER_EXT", Value: uint32(33586)},
			{Name: "GL_PIXEL_CUBIC_WEIGHT_EXT", Value: uint32(33587)},
			{Name: "GL_CUBIC_EXT", Value: uint32(33588)},
			{Name: "GL_AVERAGE_EXT", Value: uint32(33589)},
			{Name: "GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT", Value: uint32(33590)},
			{Name: "GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT", Value: uint32(33591)},
			{Name: "GL_PIXEL_TRANSFORM_2D_MATRIX_EXT", Value: uint32(33592)},
			{Name: "GL_FRAGMENT_MATERIAL_EXT", Value: uint32(33609)},
			{Name: "GL_FRAGMENT_NORMAL_EXT", Value: uint32(33610)},
			{Name: "GL_FRAGMENT_COLOR_EXT", Value: uint32(33612)},
			{Name: "GL_ATTENUATION_EXT", Value: uint32(33613)},
			{Name: "GL_SHADOW_ATTENUATION_EXT", Value: uint32(33614)},
			{Name: "GL_TEXTURE_APPLICATION_MODE_EXT", Value: uint32(33615)},
			{Name: "GL_TEXTURE_LIGHT_EXT", Value: uint32(33616)},
			{Name: "GL_TEXTURE_MATERIAL_FACE_EXT", Value: uint32(33617)},
			{Name: "GL_TEXTURE_MATERIAL_PARAMETER_EXT", Value: uint32(33618)},
			{Name: "GL_PIXEL_TEXTURE_SGIS", Value: uint32(33619)},
			{Name: "GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS", Value: uint32(33620)},
			{Name: "GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS", Value: uint32(33621)},
			{Name: "GL_PIXEL_GROUP_COLOR_SGIS", Value: uint32(33622)},
			{Name: "GL_LINE_QUALITY_HINT_SGIX", Value: uint32(33627)},
			{Name: "GL_ASYNC_TEX_IMAGE_SGIX", Value: uint32(33628)},
			{Name: "GL_ASYNC_DRAW_PIXELS_SGIX", Value: uint32(33629)},
			{Name: "GL_ASYNC_READ_PIXELS_SGIX", Value: uint32(33630)},
			{Name: "GL_MAX_ASYNC_TEX_IMAGE_SGIX", Value: uint32(33631)},
			{Name: "GL_MAX_ASYNC_DRAW_PIXELS_SGIX", Value: uint32(33632)},
			{Name: "GL_MAX_ASYNC_READ_PIXELS_SGIX", Value: uint32(33633)},
			{Name: "GL_UNSIGNED_BYTE_2_3_3_REV_EXT", Value: uint32(33634)},
			{Name: "GL_UNSIGNED_BYTE_2_3_3_REV", Value: uint32(33634)},
			{Name: "GL_UNSIGNED_SHORT_5_6_5", Value: uint32(33635)},
			{Name: "GL_UNSIGNED_SHORT_5_6_5_EXT", Value: uint32(33635)},
			{Name: "GL_UNSIGNED_SHORT_5_6_5_REV_EXT", Value: uint32(33636)},
			{Name: "GL_UNSIGNED_SHORT_5_6_5_REV", Value: uint32(33636)},
			{Name: "GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG", Value: uint32(33637)},
			{Name: "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT", Value: uint32(33637)},
			{Name: "GL_UNSIGNED_SHORT_4_4_4_4_REV", Value: uint32(33637)},
			{Name: "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT", Value: uint32(33638)},
			{Name: "GL_UNSIGNED_SHORT_1_5_5_5_REV", Value: uint32(33638)},
			{Name: "GL_UNSIGNED_INT_8_8_8_8_REV_EXT", Value: uint32(33639)},
			{Name: "GL_UNSIGNED_INT_8_8_8_8_REV", Value: uint32(33639)},
			{Name: "GL_UNSIGNED_INT_2_10_10_10_REV_EXT", Value: uint32(33640)},
			{Name: "GL_UNSIGNED_INT_2_10_10_10_REV", Value: uint32(33640)},
			{Name: "GL_TEXTURE_MAX_CLAMP_S_SGIX", Value: uint32(33641)},
			{Name: "GL_TEXTURE_MAX_CLAMP_T_SGIX", Value: uint32(33642)},
			{Name: "GL_TEXTURE_MAX_CLAMP_R_SGIX", Value: uint32(33643)},
			{Name: "GL_MIRRORED_REPEAT_ARB", Value: uint32(33648)},
			{Name: "GL_MIRRORED_REPEAT", Value: uint32(33648)},
			{Name: "GL_MIRRORED_REPEAT_OES", Value: uint32(33648)},
			{Name: "GL_MIRRORED_REPEAT_IBM", Value: uint32(33648)},
			{Name: "GL_RGB_S3TC", Value: uint32(33696)},
			{Name: "GL_RGB4_S3TC", Value: uint32(33697)},
			{Name: "GL_RGBA_S3TC", Value: uint32(33698)},
			{Name: "GL_RGBA4_S3TC", Value: uint32(33699)},
			{Name: "GL_RGBA_DXT5_S3TC", Value: uint32(33700)},
			{Name: "GL_RGBA4_DXT5_S3TC", Value: uint32(33701)},
			{Name: "GL_VERTEX_PRECLIP_SGIX", Value: uint32(33774)},
			{Name: "GL_VERTEX_PRECLIP_HINT_SGIX", Value: uint32(33775)},
			{Name: "GL_COMPRESSED_RGB_S3TC_DXT1_EXT", Value: uint32(33776)},
			{Name: "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT", Value: uint32(33777)},
			{Name: "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE", Value: uint32(33778)},
			{Name: "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT", Value: uint32(33778)},
			{Name: "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT", Value: uint32(33779)},
			{Name: "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE", Value: uint32(33779)},
			{Name: "GL_PARALLEL_ARRAYS_INTEL", Value: uint32(33780)},
			{Name: "GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL", Value: uint32(33781)},
			{Name: "GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL", Value: uint32(33782)},
			{Name: "GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL", Value: uint32(33783)},
			{Name: "GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL", Value: uint32(33784)},
			{Name: "GL_PERFQUERY_DONOT_FLUSH_INTEL", Value: uint32(33785)},
			{Name: "GL_PERFQUERY_FLUSH_INTEL", Value: uint32(33786)},
			{Name: "GL_PERFQUERY_WAIT_INTEL", Value: uint32(33787)},
			{Name: "GL_TEXTURE_MEMORY_LAYOUT_INTEL", Value: uint32(33791)},
			{Name: "GL_FRAGMENT_LIGHTING_SGIX", Value: uint32(33792)},
			{Name: "GL_FRAGMENT_COLOR_MATERIAL_SGIX", Value: uint32(33793)},
			{Name: "GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX", Value: uint32(33794)},
			{Name: "GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX", Value: uint32(33795)},
			{Name: "GL_MAX_FRAGMENT_LIGHTS_SGIX", Value: uint32(33796)},
			{Name: "GL_MAX_ACTIVE_LIGHTS_SGIX", Value: uint32(33797)},
			{Name: "GL_CURRENT_RASTER_NORMAL_SGIX", Value: uint32(33798)},
			{Name: "GL_LIGHT_ENV_MODE_SGIX", Value: uint32(33799)},
			{Name: "GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX", Value: uint32(33800)},
			{Name: "GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX", Value: uint32(33801)},
			{Name: "GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX", Value: uint32(33802)},
			{Name: "GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX", Value: uint32(33803)},
			{Name: "GL_FRAGMENT_LIGHT0_SGIX", Value: uint32(33804)},
			{Name: "GL_FRAGMENT_LIGHT1_SGIX", Value: uint32(33805)},
			{Name: "GL_FRAGMENT_LIGHT2_SGIX", Value: uint32(33806)},
			{Name: "GL_FRAGMENT_LIGHT3_SGIX", Value: uint32(33807)},
			{Name: "GL_FRAGMENT_LIGHT4_SGIX", Value: uint32(33808)},
			{Name: "GL_FRAGMENT_LIGHT5_SGIX", Value: uint32(33809)},
			{Name: "GL_FRAGMENT_LIGHT6_SGIX", Value: uint32(33810)},
			{Name: "GL_FRAGMENT_LIGHT7_SGIX", Value: uint32(33811)},
			{Name: "GL_PACK_RESAMPLE_SGIX", Value: uint32(33838)},
			{Name: "GL_UNPACK_RESAMPLE_SGIX", Value: uint32(33839)},
			{Name: "GL_RESAMPLE_DECIMATE_SGIX", Value: uint32(33840)},
			{Name: "GL_RESAMPLE_REPLICATE_SGIX", Value: uint32(33843)},
			{Name: "GL_RESAMPLE_ZERO_FILL_SGIX", Value: uint32(33844)},
			{Name: "GL_TANGENT_ARRAY_EXT", Value: uint32(33849)},
			{Name: "GL_BINORMAL_ARRAY_EXT", Value: uint32(33850)},
			{Name: "GL_CURRENT_TANGENT_EXT", Value: uint32(33851)},
			{Name: "GL_CURRENT_BINORMAL_EXT", Value: uint32(33852)},
			{Name: "GL_TANGENT_ARRAY_TYPE_EXT", Value: uint32(33854)},
			{Name: "GL_TANGENT_ARRAY_STRIDE_EXT", Value: uint32(33855)},
			{Name: "GL_BINORMAL_ARRAY_TYPE_EXT", Value: uint32(33856)},
			{Name: "GL_BINORMAL_ARRAY_STRIDE_EXT", Value: uint32(33857)},
			{Name: "GL_TANGENT_ARRAY_POINTER_EXT", Value: uint32(33858)},
			{Name: "GL_BINORMAL_ARRAY_POINTER_EXT", Value: uint32(33859)},
			{Name: "GL_MAP1_TANGENT_EXT", Value: uint32(33860)},
			{Name: "GL_MAP2_TANGENT_EXT", Value: uint32(33861)},
			{Name: "GL_MAP1_BINORMAL_EXT", Value: uint32(33862)},
			{Name: "GL_MAP2_BINORMAL_EXT", Value: uint32(33863)},
			{Name: "GL_NEAREST_CLIPMAP_NEAREST_SGIX", Value: uint32(33869)},
			{Name: "GL_NEAREST_CLIPMAP_LINEAR_SGIX", Value: uint32(33870)},
			{Name: "GL_LINEAR_CLIPMAP_NEAREST_SGIX", Value: uint32(33871)},
			{Name: "GL_FOG_COORDINATE_SOURCE", Value: uint32(33872)},
			{Name: "GL_FOG_COORDINATE_SOURCE_EXT", Value: uint32(33872)},
			{Name: "GL_FOG_COORD_SRC", Value: uint32(33872)},
			{Name: "GL_FOG_COORDINATE_EXT", Value: uint32(33873)},
			{Name: "GL_FOG_COORDINATE", Value: uint32(33873)},
			{Name: "GL_FOG_COORD", Value: uint32(33873)},
			{Name: "GL_FRAGMENT_DEPTH", Value: uint32(33874)},
			{Name: "GL_FRAGMENT_DEPTH_EXT", Value: uint32(33874)},
			{Name: "GL_CURRENT_FOG_COORD", Value: uint32(33875)},
			{Name: "GL_CURRENT_FOG_COORDINATE_EXT", Value: uint32(33875)},
			{Name: "GL_CURRENT_FOG_COORDINATE", Value: uint32(33875)},
			{Name: "GL_FOG_COORDINATE_ARRAY_TYPE_EXT", Value: uint32(33876)},
			{Name: "GL_FOG_COORD_ARRAY_TYPE", Value: uint32(33876)},
			{Name: "GL_FOG_COORDINATE_ARRAY_TYPE", Value: uint32(33876)},
			{Name: "GL_FOG_COORD_ARRAY_STRIDE", Value: uint32(33877)},
			{Name: "GL_FOG_COORDINATE_ARRAY_STRIDE_EXT", Value: uint32(33877)},
			{Name: "GL_FOG_COORDINATE_ARRAY_STRIDE", Value: uint32(33877)},
			{Name: "GL_FOG_COORDINATE_ARRAY_POINTER_EXT", Value: uint32(33878)},
			{Name: "GL_FOG_COORD_ARRAY_POINTER", Value: uint32(33878)},
			{Name: "GL_FOG_COORDINATE_ARRAY_POINTER", Value: uint32(33878)},
			{Name: "GL_FOG_COORD_ARRAY", Value: uint32(33879)},
			{Name: "GL_FOG_COORDINATE_ARRAY_EXT", Value: uint32(33879)},
			{Name: "GL_FOG_COORDINATE_ARRAY", Value: uint32(33879)},
			{Name: "GL_COLOR_SUM", Value: uint32(33880)},
			{Name: "GL_COLOR_SUM_EXT", Value: uint32(33880)},
			{Name: "GL_COLOR_SUM_ARB", Value: uint32(33880)},
			{Name: "GL_CURRENT_SECONDARY_COLOR", Value: uint32(33881)},
			{Name: "GL_CURRENT_SECONDARY_COLOR_EXT", Value: uint32(33881)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_SIZE_EXT", Value: uint32(33882)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_SIZE", Value: uint32(33882)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_TYPE_EXT", Value: uint32(33883)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_TYPE", Value: uint32(33883)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT", Value: uint32(33884)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_STRIDE", Value: uint32(33884)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_POINTER_EXT", Value: uint32(33885)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_POINTER", Value: uint32(33885)},
			{Name: "GL_SECONDARY_COLOR_ARRAY", Value: uint32(33886)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_EXT", Value: uint32(33886)},
			{Name: "GL_CURRENT_RASTER_SECONDARY_COLOR", Value: uint32(33887)},
			{Name: "GL_ALIASED_POINT_SIZE_RANGE", Value: uint32(33901)},
			{Name: "GL_ALIASED_LINE_WIDTH_RANGE", Value: uint32(33902)},
			{Name: "GL_SCREEN_COORDINATES_REND", Value: uint32(33936)},
			{Name: "GL_INVERTED_SCREEN_W_REND", Value: uint32(33937)},
			{Name: "GL_TEXTURE0_ARB", Value: uint32(33984)},
			{Name: "GL_TEXTURE0", Value: uint32(33984)},
			{Name: "GL_TEXTURE1_ARB", Value: uint32(33985)},
			{Name: "GL_TEXTURE1", Value: uint32(33985)},
			{Name: "GL_TEXTURE2", Value: uint32(33986)},
			{Name: "GL_TEXTURE2_ARB", Value: uint32(33986)},
			{Name: "GL_TEXTURE3_ARB", Value: uint32(33987)},
			{Name: "GL_TEXTURE3", Value: uint32(33987)},
			{Name: "GL_TEXTURE4_ARB", Value: uint32(33988)},
			{Name: "GL_TEXTURE4", Value: uint32(33988)},
			{Name: "GL_TEXTURE5", Value: uint32(33989)},
			{Name: "GL_TEXTURE5_ARB", Value: uint32(33989)},
			{Name: "GL_TEXTURE6_ARB", Value: uint32(33990)},
			{Name: "GL_TEXTURE6", Value: uint32(33990)},
			{Name: "GL_TEXTURE7", Value: uint32(33991)},
			{Name: "GL_TEXTURE7_ARB", Value: uint32(33991)},
			{Name: "GL_TEXTURE8", Value: uint32(33992)},
			{Name: "GL_TEXTURE8_ARB", Value: uint32(33992)},
			{Name: "GL_TEXTURE9_ARB", Value: uint32(33993)},
			{Name: "GL_TEXTURE9", Value: uint32(33993)},
			{Name: "GL_TEXTURE10_ARB", Value: uint32(33994)},
			{Name: "GL_TEXTURE10", Value: uint32(33994)},
			{Name: "GL_TEXTURE11", Value: uint32(33995)},
			{Name: "GL_TEXTURE11_ARB", Value: uint32(33995)},
			{Name: "GL_TEXTURE12_ARB", Value: uint32(33996)},
			{Name: "GL_TEXTURE12", Value: uint32(33996)},
			{Name: "GL_TEXTURE13", Value: uint32(33997)},
			{Name: "GL_TEXTURE13_ARB", Value: uint32(33997)},
			{Name: "GL_TEXTURE14", Value: uint32(33998)},
			{Name: "GL_TEXTURE14_ARB", Value: uint32(33998)},
			{Name: "GL_TEXTURE15", Value: uint32(33999)},
			{Name: "GL_TEXTURE15_ARB", Value: uint32(33999)},
			{Name: "GL_TEXTURE16_ARB", Value: uint32(34000)},
			{Name: "GL_TEXTURE16", Value: uint32(34000)},
			{Name: "GL_TEXTURE17_ARB", Value: uint32(34001)},
			{Name: "GL_TEXTURE17", Value: uint32(34001)},
			{Name: "GL_TEXTURE18_ARB", Value: uint32(34002)},
			{Name: "GL_TEXTURE18", Value: uint32(34002)},
			{Name: "GL_TEXTURE19_ARB", Value: uint32(34003)},
			{Name: "GL_TEXTURE19", Value: uint32(34003)},
			{Name: "GL_TEXTURE20_ARB", Value: uint32(34004)},
			{Name: "GL_TEXTURE20", Value: uint32(34004)},
			{Name: "GL_TEXTURE21", Value: uint32(34005)},
			{Name: "GL_TEXTURE21_ARB", Value: uint32(34005)},
			{Name: "GL_TEXTURE22", Value: uint32(34006)},
			{Name: "GL_TEXTURE22_ARB", Value: uint32(34006)},
			{Name: "GL_TEXTURE23_ARB", Value: uint32(34007)},
			{Name: "GL_TEXTURE23", Value: uint32(34007)},
			{Name: "GL_TEXTURE24_ARB", Value: uint32(34008)},
			{Name: "GL_TEXTURE24", Value: uint32(34008)},
			{Name: "GL_TEXTURE25", Value: uint32(34009)},
			{Name: "GL_TEXTURE25_ARB", Value: uint32(34009)},
			{Name: "GL_TEXTURE26_ARB", Value: uint32(34010)},
			{Name: "GL_TEXTURE26", Value: uint32(34010)},
			{Name: "GL_TEXTURE27_ARB", Value: uint32(34011)},
			{Name: "GL_TEXTURE27", Value: uint32(34011)},
			{Name: "GL_TEXTURE28", Value: uint32(34012)},
			{Name: "GL_TEXTURE28_ARB", Value: uint32(34012)},
			{Name: "GL_TEXTURE29", Value: uint32(34013)},
			{Name: "GL_TEXTURE29_ARB", Value: uint32(34013)},
			{Name: "GL_TEXTURE30", Value: uint32(34014)},
			{Name: "GL_TEXTURE30_ARB", Value: uint32(34014)},
			{Name: "GL_TEXTURE31_ARB", Value: uint32(34015)},
			{Name: "GL_TEXTURE31", Value: uint32(34015)},
			{Name: "GL_ACTIVE_TEXTURE_ARB", Value: uint32(34016)},
			{Name: "GL_ACTIVE_TEXTURE", Value: uint32(34016)},
			{Name: "GL_CLIENT_ACTIVE_TEXTURE_ARB", Value: uint32(34017)},
			{Name: "GL_CLIENT_ACTIVE_TEXTURE", Value: uint32(34017)},
			{Name: "GL_MAX_TEXTURE_UNITS_ARB", Value: uint32(34018)},
			{Name: "GL_MAX_TEXTURE_UNITS", Value: uint32(34018)},
			{Name: "GL_TRANSPOSE_MODELVIEW_MATRIX", Value: uint32(34019)},
			{Name: "GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV", Value: uint32(34019)},
			{Name: "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB", Value: uint32(34019)},
			{Name: "GL_TRANSPOSE_PROJECTION_MATRIX_ARB", Value: uint32(34020)},
			{Name: "GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV", Value: uint32(34020)},
			{Name: "GL_TRANSPOSE_PROJECTION_MATRIX", Value: uint32(34020)},
			{Name: "GL_TRANSPOSE_TEXTURE_MATRIX_ARB", Value: uint32(34021)},
			{Name: "GL_TRANSPOSE_TEXTURE_MATRIX", Value: uint32(34021)},
			{Name: "GL_TRANSPOSE_COLOR_MATRIX", Value: uint32(34022)},
			{Name: "GL_TRANSPOSE_COLOR_MATRIX_ARB", Value: uint32(34022)},
			{Name: "GL_SUBTRACT_ARB", Value: uint32(34023)},
			{Name: "GL_SUBTRACT", Value: uint32(34023)},
			{Name: "GL_MAX_RENDERBUFFER_SIZE", Value: uint32(34024)},
			{Name: "GL_MAX_RENDERBUFFER_SIZE_OES", Value: uint32(34024)},
			{Name: "GL_MAX_RENDERBUFFER_SIZE_EXT", Value: uint32(34024)},
			{Name: "GL_COMPRESSED_ALPHA_ARB", Value: uint32(34025)},
			{Name: "GL_COMPRESSED_ALPHA", Value: uint32(34025)},
			{Name: "GL_COMPRESSED_LUMINANCE", Value: uint32(34026)},
			{Name: "GL_COMPRESSED_LUMINANCE_ARB", Value: uint32(34026)},
			{Name: "GL_COMPRESSED_LUMINANCE_ALPHA", Value: uint32(34027)},
			{Name: "GL_COMPRESSED_LUMINANCE_ALPHA_ARB", Value: uint32(34027)},
			{Name: "GL_COMPRESSED_INTENSITY", Value: uint32(34028)},
			{Name: "GL_COMPRESSED_INTENSITY_ARB", Value: uint32(34028)},
			{Name: "GL_COMPRESSED_RGB", Value: uint32(34029)},
			{Name: "GL_COMPRESSED_RGB_ARB", Value: uint32(34029)},
			{Name: "GL_COMPRESSED_RGBA", Value: uint32(34030)},
			{Name: "GL_COMPRESSED_RGBA_ARB", Value: uint32(34030)},
			{Name: "GL_TEXTURE_COMPRESSION_HINT_ARB", Value: uint32(34031)},
			{Name: "GL_TEXTURE_COMPRESSION_HINT", Value: uint32(34031)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER", Value: uint32(34032)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER", Value: uint32(34033)},
			{Name: "GL_ALL_COMPLETED_NV", Value: uint32(34034)},
			{Name: "GL_FENCE_STATUS_NV", Value: uint32(34035)},
			{Name: "GL_FENCE_CONDITION_NV", Value: uint32(34036)},
			{Name: "GL_TEXTURE_RECTANGLE_NV", Value: uint32(34037)},
			{Name: "GL_TEXTURE_RECTANGLE", Value: uint32(34037)},
			{Name: "GL_TEXTURE_RECTANGLE_ARB", Value: uint32(34037)},
			{Name: "GL_TEXTURE_BINDING_RECTANGLE_NV", Value: uint32(34038)},
			{Name: "GL_TEXTURE_BINDING_RECTANGLE_ARB", Value: uint32(34038)},
			{Name: "GL_TEXTURE_BINDING_RECTANGLE", Value: uint32(34038)},
			{Name: "GL_PROXY_TEXTURE_RECTANGLE", Value: uint32(34039)},
			{Name: "GL_PROXY_TEXTURE_RECTANGLE_NV", Value: uint32(34039)},
			{Name: "GL_PROXY_TEXTURE_RECTANGLE_ARB", Value: uint32(34039)},
			{Name: "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", Value: uint32(34040)},
			{Name: "GL_MAX_RECTANGLE_TEXTURE_SIZE", Value: uint32(34040)},
			{Name: "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB", Value: uint32(34040)},
			{Name: "GL_DEPTH_STENCIL_NV", Value: uint32(34041)},
			{Name: "GL_DEPTH_STENCIL_EXT", Value: uint32(34041)},
			{Name: "GL_DEPTH_STENCIL_OES", Value: uint32(34041)},
			{Name: "GL_DEPTH_STENCIL", Value: uint32(34041)},
			{Name: "GL_UNSIGNED_INT_24_8_EXT", Value: uint32(34042)},
			{Name: "GL_UNSIGNED_INT_24_8_OES", Value: uint32(34042)},
			{Name: "GL_UNSIGNED_INT_24_8_NV", Value: uint32(34042)},
			{Name: "GL_UNSIGNED_INT_24_8", Value: uint32(34042)},
			{Name: "GL_MAX_TEXTURE_LOD_BIAS_EXT", Value: uint32(34045)},
			{Name: "GL_MAX_TEXTURE_LOD_BIAS", Value: uint32(34045)},
			{Name: "GL_TEXTURE_MAX_ANISOTROPY_EXT", Value: uint32(34046)},
			{Name: "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT", Value: uint32(34047)},
			{Name: "GL_TEXTURE_FILTER_CONTROL", Value: uint32(34048)},
			{Name: "GL_TEXTURE_FILTER_CONTROL_EXT", Value: uint32(34048)},
			{Name: "GL_TEXTURE_LOD_BIAS", Value: uint32(34049)},
			{Name: "GL_TEXTURE_LOD_BIAS_EXT", Value: uint32(34049)},
			{Name: "GL_MODELVIEW1_STACK_DEPTH_EXT", Value: uint32(34050)},
			{Name: "GL_COMBINE4_NV", Value: uint32(34051)},
			{Name: "GL_MAX_SHININESS_NV", Value: uint32(34052)},
			{Name: "GL_MAX_SPOT_EXPONENT_NV", Value: uint32(34053)},
			{Name: "GL_MODELVIEW1_MATRIX_EXT", Value: uint32(34054)},
			{Name: "GL_INCR_WRAP_EXT", Value: uint32(34055)},
			{Name: "GL_INCR_WRAP", Value: uint32(34055)},
			{Name: "GL_INCR_WRAP_OES", Value: uint32(34055)},
			{Name: "GL_DECR_WRAP_EXT", Value: uint32(34056)},
			{Name: "GL_DECR_WRAP_OES", Value: uint32(34056)},
			{Name: "GL_DECR_WRAP", Value: uint32(34056)},
			{Name: "GL_VERTEX_WEIGHTING_EXT", Value: uint32(34057)},
			{Name: "GL_MODELVIEW1_EXT", Value: uint32(34058)},
			{Name: "GL_MODELVIEW1_ARB", Value: uint32(34058)},
			{Name: "GL_CURRENT_VERTEX_WEIGHT_EXT", Value: uint32(34059)},
			{Name: "GL_VERTEX_WEIGHT_ARRAY_EXT", Value: uint32(34060)},
			{Name: "GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT", Value: uint32(34061)},
			{Name: "GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT", Value: uint32(34062)},
			{Name: "GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT", Value: uint32(34063)},
			{Name: "GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT", Value: uint32(34064)},
			{Name: "GL_NORMAL_MAP_EXT", Value: uint32(34065)},
			{Name: "GL_NORMAL_MAP", Value: uint32(34065)},
			{Name: "GL_NORMAL_MAP_OES", Value: uint32(34065)},
			{Name: "GL_NORMAL_MAP_NV", Value: uint32(34065)},
			{Name: "GL_NORMAL_MAP_ARB", Value: uint32(34065)},
			{Name: "GL_REFLECTION_MAP_ARB", Value: uint32(34066)},
			{Name: "GL_REFLECTION_MAP_OES", Value: uint32(34066)},
			{Name: "GL_REFLECTION_MAP_NV", Value: uint32(34066)},
			{Name: "GL_REFLECTION_MAP_EXT", Value: uint32(34066)},
			{Name: "GL_REFLECTION_MAP", Value: uint32(34066)},
			{Name: "GL_TEXTURE_CUBE_MAP_OES", Value: uint32(34067)},
			{Name: "GL_TEXTURE_CUBE_MAP_EXT", Value: uint32(34067)},
			{Name: "GL_TEXTURE_CUBE_MAP_ARB", Value: uint32(34067)},
			{Name: "GL_TEXTURE_CUBE_MAP", Value: uint32(34067)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_EXT", Value: uint32(34068)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_ARB", Value: uint32(34068)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_OES", Value: uint32(34068)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP", Value: uint32(34068)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES", Value: uint32(34069)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT", Value: uint32(34069)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB", Value: uint32(34069)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_X", Value: uint32(34069)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES", Value: uint32(34070)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_X", Value: uint32(34070)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB", Value: uint32(34070)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT", Value: uint32(34070)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB", Value: uint32(34071)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT", Value: uint32(34071)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Y", Value: uint32(34071)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES", Value: uint32(34071)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB", Value: uint32(34072)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT", Value: uint32(34072)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES", Value: uint32(34072)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y", Value: uint32(34072)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Z", Value: uint32(34073)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT", Value: uint32(34073)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES", Value: uint32(34073)},
			{Name: "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB", Value: uint32(34073)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB", Value: uint32(34074)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES", Value: uint32(34074)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT", Value: uint32(34074)},
			{Name: "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z", Value: uint32(34074)},
			{Name: "GL_PROXY_TEXTURE_CUBE_MAP", Value: uint32(34075)},
			{Name: "GL_PROXY_TEXTURE_CUBE_MAP_EXT", Value: uint32(34075)},
			{Name: "GL_PROXY_TEXTURE_CUBE_MAP_ARB", Value: uint32(34075)},
			{Name: "GL_MAX_CUBE_MAP_TEXTURE_SIZE", Value: uint32(34076)},
			{Name: "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", Value: uint32(34076)},
			{Name: "GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT", Value: uint32(34076)},
			{Name: "GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES", Value: uint32(34076)},
			{Name: "GL_VERTEX_ARRAY_RANGE_APPLE", Value: uint32(34077)},
			{Name: "GL_VERTEX_ARRAY_RANGE_NV", Value: uint32(34077)},
			{Name: "GL_VERTEX_ARRAY_RANGE_LENGTH_NV", Value: uint32(34078)},
			{Name: "GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE", Value: uint32(34078)},
			{Name: "GL_VERTEX_ARRAY_RANGE_VALID_NV", Value: uint32(34079)},
			{Name: "GL_VERTEX_ARRAY_STORAGE_HINT_APPLE", Value: uint32(34079)},
			{Name: "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV", Value: uint32(34080)},
			{Name: "GL_VERTEX_ARRAY_RANGE_POINTER_APPLE", Value: uint32(34081)},
			{Name: "GL_VERTEX_ARRAY_RANGE_POINTER_NV", Value: uint32(34081)},
			{Name: "GL_REGISTER_COMBINERS_NV", Value: uint32(34082)},
			{Name: "GL_VARIABLE_A_NV", Value: uint32(34083)},
			{Name: "GL_VARIABLE_B_NV", Value: uint32(34084)},
			{Name: "GL_VARIABLE_C_NV", Value: uint32(34085)},
			{Name: "GL_VARIABLE_D_NV", Value: uint32(34086)},
			{Name: "GL_VARIABLE_E_NV", Value: uint32(34087)},
			{Name: "GL_VARIABLE_F_NV", Value: uint32(34088)},
			{Name: "GL_VARIABLE_G_NV", Value: uint32(34089)},
			{Name: "GL_CONSTANT_COLOR0_NV", Value: uint32(34090)},
			{Name: "GL_CONSTANT_COLOR1_NV", Value: uint32(34091)},
			{Name: "GL_PRIMARY_COLOR_NV", Value: uint32(34092)},
			{Name: "GL_SECONDARY_COLOR_NV", Value: uint32(34093)},
			{Name: "GL_SPARE0_NV", Value: uint32(34094)},
			{Name: "GL_SPARE1_NV", Value: uint32(34095)},
			{Name: "GL_DISCARD_NV", Value: uint32(34096)},
			{Name: "GL_E_TIMES_F_NV", Value: uint32(34097)},
			{Name: "GL_SPARE0_PLUS_SECONDARY_COLOR_NV", Value: uint32(34098)},
			{Name: "GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV", Value: uint32(34099)},
			{Name: "GL_MULTISAMPLE_FILTER_HINT_NV", Value: uint32(34100)},
			{Name: "GL_PER_STAGE_CONSTANTS_NV", Value: uint32(34101)},
			{Name: "GL_UNSIGNED_IDENTITY_NV", Value: uint32(34102)},
			{Name: "GL_UNSIGNED_INVERT_NV", Value: uint32(34103)},
			{Name: "GL_EXPAND_NORMAL_NV", Value: uint32(34104)},
			{Name: "GL_EXPAND_NEGATE_NV", Value: uint32(34105)},
			{Name: "GL_HALF_BIAS_NORMAL_NV", Value: uint32(34106)},
			{Name: "GL_HALF_BIAS_NEGATE_NV", Value: uint32(34107)},
			{Name: "GL_SIGNED_IDENTITY_NV", Value: uint32(34108)},
			{Name: "GL_SIGNED_NEGATE_NV", Value: uint32(34109)},
			{Name: "GL_SCALE_BY_TWO_NV", Value: uint32(34110)},
			{Name: "GL_SCALE_BY_FOUR_NV", Value: uint32(34111)},
			{Name: "GL_SCALE_BY_ONE_HALF_NV", Value: uint32(34112)},
			{Name: "GL_BIAS_BY_NEGATIVE_ONE_HALF_NV", Value: uint32(34113)},
			{Name: "GL_COMBINER_INPUT_NV", Value: uint32(34114)},
			{Name: "GL_COMBINER_MAPPING_NV", Value: uint32(34115)},
			{Name: "GL_COMBINER_COMPONENT_USAGE_NV", Value: uint32(34116)},
			{Name: "GL_COMBINER_AB_DOT_PRODUCT_NV", Value: uint32(34117)},
			{Name: "GL_COMBINER_CD_DOT_PRODUCT_NV", Value: uint32(34118)},
			{Name: "GL_COMBINER_MUX_SUM_NV", Value: uint32(34119)},
			{Name: "GL_COMBINER_SCALE_NV", Value: uint32(34120)},
			{Name: "GL_COMBINER_BIAS_NV", Value: uint32(34121)},
			{Name: "GL_COMBINER_AB_OUTPUT_NV", Value: uint32(34122)},
			{Name: "GL_COMBINER_CD_OUTPUT_NV", Value: uint32(34123)},
			{Name: "GL_COMBINER_SUM_OUTPUT_NV", Value: uint32(34124)},
			{Name: "GL_MAX_GENERAL_COMBINERS_NV", Value: uint32(34125)},
			{Name: "GL_NUM_GENERAL_COMBINERS_NV", Value: uint32(34126)},
			{Name: "GL_COLOR_SUM_CLAMP_NV", Value: uint32(34127)},
			{Name: "GL_COMBINER0_NV", Value: uint32(34128)},
			{Name: "GL_COMBINER1_NV", Value: uint32(34129)},
			{Name: "GL_COMBINER2_NV", Value: uint32(34130)},
			{Name: "GL_COMBINER3_NV", Value: uint32(34131)},
			{Name: "GL_COMBINER4_NV", Value: uint32(34132)},
			{Name: "GL_COMBINER5_NV", Value: uint32(34133)},
			{Name: "GL_COMBINER6_NV", Value: uint32(34134)},
			{Name: "GL_COMBINER7_NV", Value: uint32(34135)},
			{Name: "GL_PRIMITIVE_RESTART_NV", Value: uint32(34136)},
			{Name: "GL_PRIMITIVE_RESTART_INDEX_NV", Value: uint32(34137)},
			{Name: "GL_FOG_DISTANCE_MODE_NV", Value: uint32(34138)},
			{Name: "GL_EYE_RADIAL_NV", Value: uint32(34139)},
			{Name: "GL_EYE_PLANE_ABSOLUTE_NV", Value: uint32(34140)},
			{Name: "GL_EMBOSS_LIGHT_NV", Value: uint32(34141)},
			{Name: "GL_EMBOSS_CONSTANT_NV", Value: uint32(34142)},
			{Name: "GL_EMBOSS_MAP_NV", Value: uint32(34143)},
			{Name: "GL_RED_MIN_CLAMP_INGR", Value: uint32(34144)},
			{Name: "GL_GREEN_MIN_CLAMP_INGR", Value: uint32(34145)},
			{Name: "GL_BLUE_MIN_CLAMP_INGR", Value: uint32(34146)},
			{Name: "GL_ALPHA_MIN_CLAMP_INGR", Value: uint32(34147)},
			{Name: "GL_RED_MAX_CLAMP_INGR", Value: uint32(34148)},
			{Name: "GL_GREEN_MAX_CLAMP_INGR", Value: uint32(34149)},
			{Name: "GL_BLUE_MAX_CLAMP_INGR", Value: uint32(34150)},
			{Name: "GL_ALPHA_MAX_CLAMP_INGR", Value: uint32(34151)},
			{Name: "GL_INTERLACE_READ_INGR", Value: uint32(34152)},
			{Name: "GL_COMBINE_ARB", Value: uint32(34160)},
			{Name: "GL_COMBINE", Value: uint32(34160)},
			{Name: "GL_COMBINE_EXT", Value: uint32(34160)},
			{Name: "GL_COMBINE_RGB_ARB", Value: uint32(34161)},
			{Name: "GL_COMBINE_RGB_EXT", Value: uint32(34161)},
			{Name: "GL_COMBINE_RGB", Value: uint32(34161)},
			{Name: "GL_COMBINE_ALPHA_ARB", Value: uint32(34162)},
			{Name: "GL_COMBINE_ALPHA", Value: uint32(34162)},
			{Name: "GL_COMBINE_ALPHA_EXT", Value: uint32(34162)},
			{Name: "GL_RGB_SCALE", Value: uint32(34163)},
			{Name: "GL_RGB_SCALE_EXT", Value: uint32(34163)},
			{Name: "GL_RGB_SCALE_ARB", Value: uint32(34163)},
			{Name: "GL_ADD_SIGNED", Value: uint32(34164)},
			{Name: "GL_ADD_SIGNED_ARB", Value: uint32(34164)},
			{Name: "GL_ADD_SIGNED_EXT", Value: uint32(34164)},
			{Name: "GL_INTERPOLATE_ARB", Value: uint32(34165)},
			{Name: "GL_INTERPOLATE_EXT", Value: uint32(34165)},
			{Name: "GL_INTERPOLATE", Value: uint32(34165)},
			{Name: "GL_CONSTANT_NV", Value: uint32(34166)},
			{Name: "GL_CONSTANT_EXT", Value: uint32(34166)},
			{Name: "GL_CONSTANT_ARB", Value: uint32(34166)},
			{Name: "GL_CONSTANT", Value: uint32(34166)},
			{Name: "GL_PRIMARY_COLOR", Value: uint32(34167)},
			{Name: "GL_PRIMARY_COLOR_EXT", Value: uint32(34167)},
			{Name: "GL_PRIMARY_COLOR_ARB", Value: uint32(34167)},
			{Name: "GL_PREVIOUS_EXT", Value: uint32(34168)},
			{Name: "GL_PREVIOUS_ARB", Value: uint32(34168)},
			{Name: "GL_PREVIOUS", Value: uint32(34168)},
			{Name: "GL_SRC0_RGB", Value: uint32(34176)},
			{Name: "GL_SOURCE0_RGB", Value: uint32(34176)},
			{Name: "GL_SOURCE0_RGB_ARB", Value: uint32(34176)},
			{Name: "GL_SOURCE0_RGB_EXT", Value: uint32(34176)},
			{Name: "GL_SOURCE1_RGB_EXT", Value: uint32(34177)},
			{Name: "GL_SRC1_RGB", Value: uint32(34177)},
			{Name: "GL_SOURCE1_RGB", Value: uint32(34177)},
			{Name: "GL_SOURCE1_RGB_ARB", Value: uint32(34177)},
			{Name: "GL_SOURCE2_RGB_EXT", Value: uint32(34178)},
			{Name: "GL_SRC2_RGB", Value: uint32(34178)},
			{Name: "GL_SOURCE2_RGB_ARB", Value: uint32(34178)},
			{Name: "GL_SOURCE2_RGB", Value: uint32(34178)},
			{Name: "GL_SOURCE3_RGB_NV", Value: uint32(34179)},
			{Name: "GL_SOURCE0_ALPHA", Value: uint32(34184)},
			{Name: "GL_SRC0_ALPHA", Value: uint32(34184)},
			{Name: "GL_SOURCE0_ALPHA_EXT", Value: uint32(34184)},
			{Name: "GL_SOURCE0_ALPHA_ARB", Value: uint32(34184)},
			{Name: "GL_SOURCE1_ALPHA_ARB", Value: uint32(34185)},
			{Name: "GL_SOURCE1_ALPHA_EXT", Value: uint32(34185)},
			{Name: "GL_SOURCE1_ALPHA", Value: uint32(34185)},
			{Name: "GL_SRC1_ALPHA", Value: uint32(34185)},
			{Name: "GL_SOURCE2_ALPHA_ARB", Value: uint32(34186)},
			{Name: "GL_SOURCE2_ALPHA", Value: uint32(34186)},
			{Name: "GL_SRC2_ALPHA", Value: uint32(34186)},
			{Name: "GL_SOURCE2_ALPHA_EXT", Value: uint32(34186)},
			{Name: "GL_SOURCE3_ALPHA_NV", Value: uint32(34187)},
			{Name: "GL_OPERAND0_RGB_EXT", Value: uint32(34192)},
			{Name: "GL_OPERAND0_RGB", Value: uint32(34192)},
			{Name: "GL_OPERAND0_RGB_ARB", Value: uint32(34192)},
			{Name: "GL_OPERAND1_RGB_EXT", Value: uint32(34193)},
			{Name: "GL_OPERAND1_RGB_ARB", Value: uint32(34193)},
			{Name: "GL_OPERAND1_RGB", Value: uint32(34193)},
			{Name: "GL_OPERAND2_RGB", Value: uint32(34194)},
			{Name: "GL_OPERAND2_RGB_EXT", Value: uint32(34194)},
			{Name: "GL_OPERAND2_RGB_ARB", Value: uint32(34194)},
			{Name: "GL_OPERAND3_RGB_NV", Value: uint32(34195)},
			{Name: "GL_OPERAND0_ALPHA", Value: uint32(34200)},
			{Name: "GL_OPERAND0_ALPHA_ARB", Value: uint32(34200)},
			{Name: "GL_OPERAND0_ALPHA_EXT", Value: uint32(34200)},
			{Name: "GL_OPERAND1_ALPHA", Value: uint32(34201)},
			{Name: "GL_OPERAND1_ALPHA_ARB", Value: uint32(34201)},
			{Name: "GL_OPERAND1_ALPHA_EXT", Value: uint32(34201)},
			{Name: "GL_OPERAND2_ALPHA", Value: uint32(34202)},
			{Name: "GL_OPERAND2_ALPHA_ARB", Value: uint32(34202)},
			{Name: "GL_OPERAND2_ALPHA_EXT", Value: uint32(34202)},
			{Name: "GL_OPERAND3_ALPHA_NV", Value: uint32(34203)},
			{Name: "GL_PACK_SUBSAMPLE_RATE_SGIX", Value: uint32(34208)},
			{Name: "GL_UNPACK_SUBSAMPLE_RATE_SGIX", Value: uint32(34209)},
			{Name: "GL_PIXEL_SUBSAMPLE_4444_SGIX", Value: uint32(34210)},
			{Name: "GL_PIXEL_SUBSAMPLE_2424_SGIX", Value: uint32(34211)},
			{Name: "GL_PIXEL_SUBSAMPLE_4242_SGIX", Value: uint32(34212)},
			{Name: "GL_PERTURB_EXT", Value: uint32(34222)},
			{Name: "GL_TEXTURE_NORMAL_EXT", Value: uint32(34223)},
			{Name: "GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE", Value: uint32(34224)},
			{Name: "GL_TRANSFORM_HINT_APPLE", Value: uint32(34225)},
			{Name: "GL_UNPACK_CLIENT_STORAGE_APPLE", Value: uint32(34226)},
			{Name: "GL_BUFFER_OBJECT_APPLE", Value: uint32(34227)},
			{Name: "GL_STORAGE_CLIENT_APPLE", Value: uint32(34228)},
			{Name: "GL_VERTEX_ARRAY_BINDING_OES", Value: uint32(34229)},
			{Name: "GL_VERTEX_ARRAY_BINDING", Value: uint32(34229)},
			{Name: "GL_VERTEX_ARRAY_BINDING_APPLE", Value: uint32(34229)},
			{Name: "GL_TEXTURE_RANGE_LENGTH_APPLE", Value: uint32(34231)},
			{Name: "GL_TEXTURE_RANGE_POINTER_APPLE", Value: uint32(34232)},
			{Name: "GL_YCBCR_422_APPLE", Value: uint32(34233)},
			{Name: "GL_UNSIGNED_SHORT_8_8_MESA", Value: uint32(34234)},
			{Name: "GL_UNSIGNED_SHORT_8_8_APPLE", Value: uint32(34234)},
			{Name: "GL_UNSIGNED_SHORT_8_8_REV_APPLE", Value: uint32(34235)},
			{Name: "GL_UNSIGNED_SHORT_8_8_REV_MESA", Value: uint32(34235)},
			{Name: "GL_TEXTURE_STORAGE_HINT_APPLE", Value: uint32(34236)},
			{Name: "GL_STORAGE_PRIVATE_APPLE", Value: uint32(34237)},
			{Name: "GL_STORAGE_CACHED_APPLE", Value: uint32(34238)},
			{Name: "GL_STORAGE_SHARED_APPLE", Value: uint32(34239)},
			{Name: "GL_REPLACEMENT_CODE_ARRAY_SUN", Value: uint32(34240)},
			{Name: "GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN", Value: uint32(34241)},
			{Name: "GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN", Value: uint32(34242)},
			{Name: "GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN", Value: uint32(34243)},
			{Name: "GL_R1UI_V3F_SUN", Value: uint32(34244)},
			{Name: "GL_R1UI_C4UB_V3F_SUN", Value: uint32(34245)},
			{Name: "GL_R1UI_C3F_V3F_SUN", Value: uint32(34246)},
			{Name: "GL_R1UI_N3F_V3F_SUN", Value: uint32(34247)},
			{Name: "GL_R1UI_C4F_N3F_V3F_SUN", Value: uint32(34248)},
			{Name: "GL_R1UI_T2F_V3F_SUN", Value: uint32(34249)},
			{Name: "GL_R1UI_T2F_N3F_V3F_SUN", Value: uint32(34250)},
			{Name: "GL_R1UI_T2F_C4F_N3F_V3F_SUN", Value: uint32(34251)},
			{Name: "GL_SLICE_ACCUM_SUN", Value: uint32(34252)},
			{Name: "GL_QUAD_MESH_SUN", Value: uint32(34324)},
			{Name: "GL_TRIANGLE_MESH_SUN", Value: uint32(34325)},
			{Name: "GL_VERTEX_PROGRAM_NV", Value: uint32(34336)},
			{Name: "GL_VERTEX_PROGRAM_ARB", Value: uint32(34336)},
			{Name: "GL_VERTEX_STATE_PROGRAM_NV", Value: uint32(34337)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_ENABLED", Value: uint32(34338)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB", Value: uint32(34338)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_SIZE", Value: uint32(34339)},
			{Name: "GL_ATTRIB_ARRAY_SIZE_NV", Value: uint32(34339)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB", Value: uint32(34339)},
			{Name: "GL_ATTRIB_ARRAY_STRIDE_NV", Value: uint32(34340)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB", Value: uint32(34340)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_STRIDE", Value: uint32(34340)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_TYPE", Value: uint32(34341)},
			{Name: "GL_ATTRIB_ARRAY_TYPE_NV", Value: uint32(34341)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB", Value: uint32(34341)},
			{Name: "GL_CURRENT_ATTRIB_NV", Value: uint32(34342)},
			{Name: "GL_CURRENT_VERTEX_ATTRIB_ARB", Value: uint32(34342)},
			{Name: "GL_CURRENT_VERTEX_ATTRIB", Value: uint32(34342)},
			{Name: "GL_PROGRAM_LENGTH_NV", Value: uint32(34343)},
			{Name: "GL_PROGRAM_LENGTH_ARB", Value: uint32(34343)},
			{Name: "GL_PROGRAM_STRING_ARB", Value: uint32(34344)},
			{Name: "GL_PROGRAM_STRING_NV", Value: uint32(34344)},
			{Name: "GL_MODELVIEW_PROJECTION_NV", Value: uint32(34345)},
			{Name: "GL_IDENTITY_NV", Value: uint32(34346)},
			{Name: "GL_INVERSE_NV", Value: uint32(34347)},
			{Name: "GL_TRANSPOSE_NV", Value: uint32(34348)},
			{Name: "GL_INVERSE_TRANSPOSE_NV", Value: uint32(34349)},
			{Name: "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB", Value: uint32(34350)},
			{Name: "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV", Value: uint32(34350)},
			{Name: "GL_MAX_PROGRAM_MATRICES_ARB", Value: uint32(34351)},
			{Name: "GL_MAX_TRACK_MATRICES_NV", Value: uint32(34351)},
			{Name: "GL_MATRIX0_NV", Value: uint32(34352)},
			{Name: "GL_MATRIX1_NV", Value: uint32(34353)},
			{Name: "GL_MATRIX2_NV", Value: uint32(34354)},
			{Name: "GL_MATRIX3_NV", Value: uint32(34355)},
			{Name: "GL_MATRIX4_NV", Value: uint32(34356)},
			{Name: "GL_MATRIX5_NV", Value: uint32(34357)},
			{Name: "GL_MATRIX6_NV", Value: uint32(34358)},
			{Name: "GL_MATRIX7_NV", Value: uint32(34359)},
			{Name: "GL_CURRENT_MATRIX_STACK_DEPTH_NV", Value: uint32(34368)},
			{Name: "GL_CURRENT_MATRIX_STACK_DEPTH_ARB", Value: uint32(34368)},
			{Name: "GL_CURRENT_MATRIX_ARB", Value: uint32(34369)},
			{Name: "GL_CURRENT_MATRIX_NV", Value: uint32(34369)},
			{Name: "GL_VERTEX_PROGRAM_POINT_SIZE_ARB", Value: uint32(34370)},
			{Name: "GL_VERTEX_PROGRAM_POINT_SIZE", Value: uint32(34370)},
			{Name: "GL_VERTEX_PROGRAM_POINT_SIZE_NV", Value: uint32(34370)},
			{Name: "GL_PROGRAM_POINT_SIZE", Value: uint32(34370)},
			{Name: "GL_PROGRAM_POINT_SIZE_ARB", Value: uint32(34370)},
			{Name: "GL_PROGRAM_POINT_SIZE_EXT", Value: uint32(34370)},
			{Name: "GL_VERTEX_PROGRAM_TWO_SIDE", Value: uint32(34371)},
			{Name: "GL_VERTEX_PROGRAM_TWO_SIDE_ARB", Value: uint32(34371)},
			{Name: "GL_VERTEX_PROGRAM_TWO_SIDE_NV", Value: uint32(34371)},
			{Name: "GL_PROGRAM_PARAMETER_NV", Value: uint32(34372)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB", Value: uint32(34373)},
			{Name: "GL_ATTRIB_ARRAY_POINTER_NV", Value: uint32(34373)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_POINTER", Value: uint32(34373)},
			{Name: "GL_PROGRAM_TARGET_NV", Value: uint32(34374)},
			{Name: "GL_PROGRAM_RESIDENT_NV", Value: uint32(34375)},
			{Name: "GL_TRACK_MATRIX_NV", Value: uint32(34376)},
			{Name: "GL_TRACK_MATRIX_TRANSFORM_NV", Value: uint32(34377)},
			{Name: "GL_VERTEX_PROGRAM_BINDING_NV", Value: uint32(34378)},
			{Name: "GL_PROGRAM_ERROR_POSITION_NV", Value: uint32(34379)},
			{Name: "GL_PROGRAM_ERROR_POSITION_ARB", Value: uint32(34379)},
			{Name: "GL_OFFSET_TEXTURE_RECTANGLE_NV", Value: uint32(34380)},
			{Name: "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV", Value: uint32(34381)},
			{Name: "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV", Value: uint32(34382)},
			{Name: "GL_DEPTH_CLAMP_NV", Value: uint32(34383)},
			{Name: "GL_DEPTH_CLAMP", Value: uint32(34383)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY0_NV", Value: uint32(34384)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY1_NV", Value: uint32(34385)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY2_NV", Value: uint32(34386)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY3_NV", Value: uint32(34387)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY4_NV", Value: uint32(34388)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY5_NV", Value: uint32(34389)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY6_NV", Value: uint32(34390)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY7_NV", Value: uint32(34391)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY8_NV", Value: uint32(34392)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY9_NV", Value: uint32(34393)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY10_NV", Value: uint32(34394)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY11_NV", Value: uint32(34395)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY12_NV", Value: uint32(34396)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY13_NV", Value: uint32(34397)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY14_NV", Value: uint32(34398)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY15_NV", Value: uint32(34399)},
			{Name: "GL_MAP1_VERTEX_ATTRIB0_4_NV", Value: uint32(34400)},
			{Name: "GL_MAP1_VERTEX_ATTRIB1_4_NV", Value: uint32(34401)},
			{Name: "GL_MAP1_VERTEX_ATTRIB2_4_NV", Value: uint32(34402)},
			{Name: "GL_MAP1_VERTEX_ATTRIB3_4_NV", Value: uint32(34403)},
			{Name: "GL_MAP1_VERTEX_ATTRIB4_4_NV", Value: uint32(34404)},
			{Name: "GL_MAP1_VERTEX_ATTRIB5_4_NV", Value: uint32(34405)},
			{Name: "GL_MAP1_VERTEX_ATTRIB6_4_NV", Value: uint32(34406)},
			{Name: "GL_MAP1_VERTEX_ATTRIB7_4_NV", Value: uint32(34407)},
			{Name: "GL_MAP1_VERTEX_ATTRIB8_4_NV", Value: uint32(34408)},
			{Name: "GL_MAP1_VERTEX_ATTRIB9_4_NV", Value: uint32(34409)},
			{Name: "GL_MAP1_VERTEX_ATTRIB10_4_NV", Value: uint32(34410)},
			{Name: "GL_MAP1_VERTEX_ATTRIB11_4_NV", Value: uint32(34411)},
			{Name: "GL_MAP1_VERTEX_ATTRIB12_4_NV", Value: uint32(34412)},
			{Name: "GL_MAP1_VERTEX_ATTRIB13_4_NV", Value: uint32(34413)},
			{Name: "GL_MAP1_VERTEX_ATTRIB14_4_NV", Value: uint32(34414)},
			{Name: "GL_MAP1_VERTEX_ATTRIB15_4_NV", Value: uint32(34415)},
			{Name: "GL_MAP2_VERTEX_ATTRIB0_4_NV", Value: uint32(34416)},
			{Name: "GL_MAP2_VERTEX_ATTRIB1_4_NV", Value: uint32(34417)},
			{Name: "GL_MAP2_VERTEX_ATTRIB2_4_NV", Value: uint32(34418)},
			{Name: "GL_MAP2_VERTEX_ATTRIB3_4_NV", Value: uint32(34419)},
			{Name: "GL_MAP2_VERTEX_ATTRIB4_4_NV", Value: uint32(34420)},
			{Name: "GL_MAP2_VERTEX_ATTRIB5_4_NV", Value: uint32(34421)},
			{Name: "GL_MAP2_VERTEX_ATTRIB6_4_NV", Value: uint32(34422)},
			{Name: "GL_MAP2_VERTEX_ATTRIB7_4_NV", Value: uint32(34423)},
			{Name: "GL_PROGRAM_BINDING_ARB", Value: uint32(34423)},
			{Name: "GL_MAP2_VERTEX_ATTRIB8_4_NV", Value: uint32(34424)},
			{Name: "GL_MAP2_VERTEX_ATTRIB9_4_NV", Value: uint32(34425)},
			{Name: "GL_MAP2_VERTEX_ATTRIB10_4_NV", Value: uint32(34426)},
			{Name: "GL_MAP2_VERTEX_ATTRIB11_4_NV", Value: uint32(34427)},
			{Name: "GL_MAP2_VERTEX_ATTRIB12_4_NV", Value: uint32(34428)},
			{Name: "GL_MAP2_VERTEX_ATTRIB13_4_NV", Value: uint32(34429)},
			{Name: "GL_MAP2_VERTEX_ATTRIB14_4_NV", Value: uint32(34430)},
			{Name: "GL_MAP2_VERTEX_ATTRIB15_4_NV", Value: uint32(34431)},
			{Name: "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB", Value: uint32(34464)},
			{Name: "GL_TEXTURE_COMPRESSED_IMAGE_SIZE", Value: uint32(34464)},
			{Name: "GL_TEXTURE_COMPRESSED_ARB", Value: uint32(34465)},
			{Name: "GL_TEXTURE_COMPRESSED", Value: uint32(34465)},
			{Name: "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB", Value: uint32(34466)},
			{Name: "GL_NUM_COMPRESSED_TEXTURE_FORMATS", Value: uint32(34466)},
			{Name: "GL_COMPRESSED_TEXTURE_FORMATS", Value: uint32(34467)},
			{Name: "GL_COMPRESSED_TEXTURE_FORMATS_ARB", Value: uint32(34467)},
			{Name: "GL_MAX_VERTEX_UNITS_ARB", Value: uint32(34468)},
			{Name: "GL_MAX_VERTEX_UNITS_OES", Value: uint32(34468)},
			{Name: "GL_ACTIVE_VERTEX_UNITS_ARB", Value: uint32(34469)},
			{Name: "GL_WEIGHT_SUM_UNITY_ARB", Value: uint32(34470)},
			{Name: "GL_VERTEX_BLEND_ARB", Value: uint32(34471)},
			{Name: "GL_CURRENT_WEIGHT_ARB", Value: uint32(34472)},
			{Name: "GL_WEIGHT_ARRAY_TYPE_OES", Value: uint32(34473)},
			{Name: "GL_WEIGHT_ARRAY_TYPE_ARB", Value: uint32(34473)},
			{Name: "GL_WEIGHT_ARRAY_STRIDE_ARB", Value: uint32(34474)},
			{Name: "GL_WEIGHT_ARRAY_STRIDE_OES", Value: uint32(34474)},
			{Name: "GL_WEIGHT_ARRAY_SIZE_OES", Value: uint32(34475)},
			{Name: "GL_WEIGHT_ARRAY_SIZE_ARB", Value: uint32(34475)},
			{Name: "GL_WEIGHT_ARRAY_POINTER_OES", Value: uint32(34476)},
			{Name: "GL_WEIGHT_ARRAY_POINTER_ARB", Value: uint32(34476)},
			{Name: "GL_WEIGHT_ARRAY_OES", Value: uint32(34477)},
			{Name: "GL_WEIGHT_ARRAY_ARB", Value: uint32(34477)},
			{Name: "GL_DOT3_RGB", Value: uint32(34478)},
			{Name: "GL_DOT3_RGB_ARB", Value: uint32(34478)},
			{Name: "GL_DOT3_RGBA_IMG", Value: uint32(34479)},
			{Name: "GL_DOT3_RGBA", Value: uint32(34479)},
			{Name: "GL_DOT3_RGBA_ARB", Value: uint32(34479)},
			{Name: "GL_COMPRESSED_RGB_FXT1_3DFX", Value: uint32(34480)},
			{Name: "GL_COMPRESSED_RGBA_FXT1_3DFX", Value: uint32(34481)},
			{Name: "GL_MULTISAMPLE_3DFX", Value: uint32(34482)},
			{Name: "GL_SAMPLE_BUFFERS_3DFX", Value: uint32(34483)},
			{Name: "GL_SAMPLES_3DFX", Value: uint32(34484)},
			{Name: "GL_EVAL_2D_NV", Value: uint32(34496)},
			{Name: "GL_EVAL_TRIANGULAR_2D_NV", Value: uint32(34497)},
			{Name: "GL_MAP_TESSELLATION_NV", Value: uint32(34498)},
			{Name: "GL_MAP_ATTRIB_U_ORDER_NV", Value: uint32(34499)},
			{Name: "GL_MAP_ATTRIB_V_ORDER_NV", Value: uint32(34500)},
			{Name: "GL_EVAL_FRACTIONAL_TESSELLATION_NV", Value: uint32(34501)},
			{Name: "GL_EVAL_VERTEX_ATTRIB0_NV", Value: uint32(34502)},
			{Name: "GL_EVAL_VERTEX_ATTRIB1_NV", Value: uint32(34503)},
			{Name: "GL_EVAL_VERTEX_ATTRIB2_NV", Value: uint32(34504)},
			{Name: "GL_EVAL_VERTEX_ATTRIB3_NV", Value: uint32(34505)},
			{Name: "GL_EVAL_VERTEX_ATTRIB4_NV", Value: uint32(34506)},
			{Name: "GL_EVAL_VERTEX_ATTRIB5_NV", Value: uint32(34507)},
			{Name: "GL_EVAL_VERTEX_ATTRIB6_NV", Value: uint32(34508)},
			{Name: "GL_EVAL_VERTEX_ATTRIB7_NV", Value: uint32(34509)},
			{Name: "GL_EVAL_VERTEX_ATTRIB8_NV", Value: uint32(34510)},
			{Name: "GL_EVAL_VERTEX_ATTRIB9_NV", Value: uint32(34511)},
			{Name: "GL_EVAL_VERTEX_ATTRIB10_NV", Value: uint32(34512)},
			{Name: "GL_EVAL_VERTEX_ATTRIB11_NV", Value: uint32(34513)},
			{Name: "GL_EVAL_VERTEX_ATTRIB12_NV", Value: uint32(34514)},
			{Name: "GL_EVAL_VERTEX_ATTRIB13_NV", Value: uint32(34515)},
			{Name: "GL_EVAL_VERTEX_ATTRIB14_NV", Value: uint32(34516)},
			{Name: "GL_EVAL_VERTEX_ATTRIB15_NV", Value: uint32(34517)},
			{Name: "GL_MAX_MAP_TESSELLATION_NV", Value: uint32(34518)},
			{Name: "GL_MAX_RATIONAL_EVAL_ORDER_NV", Value: uint32(34519)},
			{Name: "GL_MAX_PROGRAM_PATCH_ATTRIBS_NV", Value: uint32(34520)},
			{Name: "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV", Value: uint32(34521)},
			{Name: "GL_UNSIGNED_INT_S8_S8_8_8_NV", Value: uint32(34522)},
			{Name: "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV", Value: uint32(34523)},
			{Name: "GL_DSDT_MAG_INTENSITY_NV", Value: uint32(34524)},
			{Name: "GL_SHADER_CONSISTENT_NV", Value: uint32(34525)},
			{Name: "GL_TEXTURE_SHADER_NV", Value: uint32(34526)},
			{Name: "GL_SHADER_OPERATION_NV", Value: uint32(34527)},
			{Name: "GL_CULL_MODES_NV", Value: uint32(34528)},
			{Name: "GL_OFFSET_TEXTURE_MATRIX_NV", Value: uint32(34529)},
			{Name: "GL_OFFSET_TEXTURE_2D_MATRIX_NV", Value: uint32(34529)},
			{Name: "GL_OFFSET_TEXTURE_2D_SCALE_NV", Value: uint32(34530)},
			{Name: "GL_OFFSET_TEXTURE_SCALE_NV", Value: uint32(34530)},
			{Name: "GL_OFFSET_TEXTURE_2D_BIAS_NV", Value: uint32(34531)},
			{Name: "GL_OFFSET_TEXTURE_BIAS_NV", Value: uint32(34531)},
			{Name: "GL_PREVIOUS_TEXTURE_INPUT_NV", Value: uint32(34532)},
			{Name: "GL_CONST_EYE_NV", Value: uint32(34533)},
			{Name: "GL_PASS_THROUGH_NV", Value: uint32(34534)},
			{Name: "GL_CULL_FRAGMENT_NV", Value: uint32(34535)},
			{Name: "GL_OFFSET_TEXTURE_2D_NV", Value: uint32(34536)},
			{Name: "GL_DEPENDENT_AR_TEXTURE_2D_NV", Value: uint32(34537)},
			{Name: "GL_DEPENDENT_GB_TEXTURE_2D_NV", Value: uint32(34538)},
			{Name: "GL_SURFACE_STATE_NV", Value: uint32(34539)},
			{Name: "GL_DOT_PRODUCT_NV", Value: uint32(34540)},
			{Name: "GL_DOT_PRODUCT_DEPTH_REPLACE_NV", Value: uint32(34541)},
			{Name: "GL_DOT_PRODUCT_TEXTURE_2D_NV", Value: uint32(34542)},
			{Name: "GL_DOT_PRODUCT_TEXTURE_3D_NV", Value: uint32(34543)},
			{Name: "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV", Value: uint32(34544)},
			{Name: "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV", Value: uint32(34545)},
			{Name: "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV", Value: uint32(34546)},
			{Name: "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV", Value: uint32(34547)},
			{Name: "GL_HILO_NV", Value: uint32(34548)},
			{Name: "GL_DSDT_NV", Value: uint32(34549)},
			{Name: "GL_DSDT_MAG_NV", Value: uint32(34550)},
			{Name: "GL_DSDT_MAG_VIB_NV", Value: uint32(34551)},
			{Name: "GL_HILO16_NV", Value: uint32(34552)},
			{Name: "GL_SIGNED_HILO_NV", Value: uint32(34553)},
			{Name: "GL_SIGNED_HILO16_NV", Value: uint32(34554)},
			{Name: "GL_SIGNED_RGBA_NV", Value: uint32(34555)},
			{Name: "GL_SIGNED_RGBA8_NV", Value: uint32(34556)},
			{Name: "GL_SURFACE_REGISTERED_NV", Value: uint32(34557)},
			{Name: "GL_SIGNED_RGB_NV", Value: uint32(34558)},
			{Name: "GL_SIGNED_RGB8_NV", Value: uint32(34559)},
			{Name: "GL_SURFACE_MAPPED_NV", Value: uint32(34560)},
			{Name: "GL_SIGNED_LUMINANCE_NV", Value: uint32(34561)},
			{Name: "GL_SIGNED_LUMINANCE8_NV", Value: uint32(34562)},
			{Name: "GL_SIGNED_LUMINANCE_ALPHA_NV", Value: uint32(34563)},
			{Name: "GL_SIGNED_LUMINANCE8_ALPHA8_NV", Value: uint32(34564)},
			{Name: "GL_SIGNED_ALPHA_NV", Value: uint32(34565)},
			{Name: "GL_SIGNED_ALPHA8_NV", Value: uint32(34566)},
			{Name: "GL_SIGNED_INTENSITY_NV", Value: uint32(34567)},
			{Name: "GL_SIGNED_INTENSITY8_NV", Value: uint32(34568)},
			{Name: "GL_DSDT8_NV", Value: uint32(34569)},
			{Name: "GL_DSDT8_MAG8_NV", Value: uint32(34570)},
			{Name: "GL_DSDT8_MAG8_INTENSITY8_NV", Value: uint32(34571)},
			{Name: "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV", Value: uint32(34572)},
			{Name: "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV", Value: uint32(34573)},
			{Name: "GL_HI_SCALE_NV", Value: uint32(34574)},
			{Name: "GL_LO_SCALE_NV", Value: uint32(34575)},
			{Name: "GL_DS_SCALE_NV", Value: uint32(34576)},
			{Name: "GL_DT_SCALE_NV", Value: uint32(34577)},
			{Name: "GL_MAGNITUDE_SCALE_NV", Value: uint32(34578)},
			{Name: "GL_VIBRANCE_SCALE_NV", Value: uint32(34579)},
			{Name: "GL_HI_BIAS_NV", Value: uint32(34580)},
			{Name: "GL_LO_BIAS_NV", Value: uint32(34581)},
			{Name: "GL_DS_BIAS_NV", Value: uint32(34582)},
			{Name: "GL_DT_BIAS_NV", Value: uint32(34583)},
			{Name: "GL_MAGNITUDE_BIAS_NV", Value: uint32(34584)},
			{Name: "GL_VIBRANCE_BIAS_NV", Value: uint32(34585)},
			{Name: "GL_TEXTURE_BORDER_VALUES_NV", Value: uint32(34586)},
			{Name: "GL_TEXTURE_HI_SIZE_NV", Value: uint32(34587)},
			{Name: "GL_TEXTURE_LO_SIZE_NV", Value: uint32(34588)},
			{Name: "GL_TEXTURE_DS_SIZE_NV", Value: uint32(34589)},
			{Name: "GL_TEXTURE_DT_SIZE_NV", Value: uint32(34590)},
			{Name: "GL_TEXTURE_MAG_SIZE_NV", Value: uint32(34591)},
			{Name: "GL_MODELVIEW2_ARB", Value: uint32(34594)},
			{Name: "GL_MODELVIEW3_ARB", Value: uint32(34595)},
			{Name: "GL_MODELVIEW4_ARB", Value: uint32(34596)},
			{Name: "GL_MODELVIEW5_ARB", Value: uint32(34597)},
			{Name: "GL_MODELVIEW6_ARB", Value: uint32(34598)},
			{Name: "GL_MODELVIEW7_ARB", Value: uint32(34599)},
			{Name: "GL_MODELVIEW8_ARB", Value: uint32(34600)},
			{Name: "GL_MODELVIEW9_ARB", Value: uint32(34601)},
			{Name: "GL_MODELVIEW10_ARB", Value: uint32(34602)},
			{Name: "GL_MODELVIEW11_ARB", Value: uint32(34603)},
			{Name: "GL_MODELVIEW12_ARB", Value: uint32(34604)},
			{Name: "GL_MODELVIEW13_ARB", Value: uint32(34605)},
			{Name: "GL_MODELVIEW14_ARB", Value: uint32(34606)},
			{Name: "GL_MODELVIEW15_ARB", Value: uint32(34607)},
			{Name: "GL_MODELVIEW16_ARB", Value: uint32(34608)},
			{Name: "GL_MODELVIEW17_ARB", Value: uint32(34609)},
			{Name: "GL_MODELVIEW18_ARB", Value: uint32(34610)},
			{Name: "GL_MODELVIEW19_ARB", Value: uint32(34611)},
			{Name: "GL_MODELVIEW20_ARB", Value: uint32(34612)},
			{Name: "GL_MODELVIEW21_ARB", Value: uint32(34613)},
			{Name: "GL_MODELVIEW22_ARB", Value: uint32(34614)},
			{Name: "GL_MODELVIEW23_ARB", Value: uint32(34615)},
			{Name: "GL_MODELVIEW24_ARB", Value: uint32(34616)},
			{Name: "GL_MODELVIEW25_ARB", Value: uint32(34617)},
			{Name: "GL_MODELVIEW26_ARB", Value: uint32(34618)},
			{Name: "GL_MODELVIEW27_ARB", Value: uint32(34619)},
			{Name: "GL_MODELVIEW28_ARB", Value: uint32(34620)},
			{Name: "GL_MODELVIEW29_ARB", Value: uint32(34621)},
			{Name: "GL_MODELVIEW30_ARB", Value: uint32(34622)},
			{Name: "GL_MODELVIEW31_ARB", Value: uint32(34623)},
			{Name: "GL_Z400_BINARY_AMD", Value: uint32(34624)},
			{Name: "GL_DOT3_RGB_EXT", Value: uint32(34624)},
			{Name: "GL_DOT3_RGBA_EXT", Value: uint32(34625)},
			{Name: "GL_PROGRAM_BINARY_LENGTH", Value: uint32(34625)},
			{Name: "GL_PROGRAM_BINARY_LENGTH_OES", Value: uint32(34625)},
			{Name: "GL_MIRROR_CLAMP_EXT", Value: uint32(34626)},
			{Name: "GL_MIRROR_CLAMP_ATI", Value: uint32(34626)},
			{Name: "GL_MIRROR_CLAMP_TO_EDGE", Value: uint32(34627)},
			{Name: "GL_MIRROR_CLAMP_TO_EDGE_ATI", Value: uint32(34627)},
			{Name: "GL_MIRROR_CLAMP_TO_EDGE_EXT", Value: uint32(34627)},
			{Name: "GL_MODULATE_ADD_ATI", Value: uint32(34628)},
			{Name: "GL_MODULATE_SIGNED_ADD_ATI", Value: uint32(34629)},
			{Name: "GL_MODULATE_SUBTRACT_ATI", Value: uint32(34630)},
			{Name: "GL_SET_AMD", Value: uint32(34634)},
			{Name: "GL_REPLACE_VALUE_AMD", Value: uint32(34635)},
			{Name: "GL_STENCIL_OP_VALUE_AMD", Value: uint32(34636)},
			{Name: "GL_STENCIL_BACK_OP_VALUE_AMD", Value: uint32(34637)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_LONG", Value: uint32(34638)},
			{Name: "GL_OCCLUSION_QUERY_EVENT_MASK_AMD", Value: uint32(34639)},
			{Name: "GL_DEPTH_STENCIL_MESA", Value: uint32(34640)},
			{Name: "GL_UNSIGNED_INT_24_8_MESA", Value: uint32(34641)},
			{Name: "GL_UNSIGNED_INT_8_24_REV_MESA", Value: uint32(34642)},
			{Name: "GL_UNSIGNED_SHORT_15_1_MESA", Value: uint32(34643)},
			{Name: "GL_UNSIGNED_SHORT_1_15_REV_MESA", Value: uint32(34644)},
			{Name: "GL_TRACE_MASK_MESA", Value: uint32(34645)},
			{Name: "GL_TRACE_NAME_MESA", Value: uint32(34646)},
			{Name: "GL_YCBCR_MESA", Value: uint32(34647)},
			{Name: "GL_PACK_INVERT_MESA", Value: uint32(34648)},
			{Name: "GL_DEBUG_OBJECT_MESA", Value: uint32(34649)},
			{Name: "GL_TEXTURE_1D_STACK_MESAX", Value: uint32(34649)},
			{Name: "GL_DEBUG_PRINT_MESA", Value: uint32(34650)},
			{Name: "GL_TEXTURE_2D_STACK_MESAX", Value: uint32(34650)},
			{Name: "GL_DEBUG_ASSERT_MESA", Value: uint32(34651)},
			{Name: "GL_PROXY_TEXTURE_1D_STACK_MESAX", Value: uint32(34651)},
			{Name: "GL_PROXY_TEXTURE_2D_STACK_MESAX", Value: uint32(34652)},
			{Name: "GL_TEXTURE_1D_STACK_BINDING_MESAX", Value: uint32(34653)},
			{Name: "GL_TEXTURE_2D_STACK_BINDING_MESAX", Value: uint32(34654)},
			{Name: "GL_STATIC_ATI", Value: uint32(34656)},
			{Name: "GL_DYNAMIC_ATI", Value: uint32(34657)},
			{Name: "GL_PRESERVE_ATI", Value: uint32(34658)},
			{Name: "GL_DISCARD_ATI", Value: uint32(34659)},
			{Name: "GL_BUFFER_SIZE_ARB", Value: uint32(34660)},
			{Name: "GL_BUFFER_SIZE", Value: uint32(34660)},
			{Name: "GL_OBJECT_BUFFER_SIZE_ATI", Value: uint32(34660)},
			{Name: "GL_BUFFER_USAGE", Value: uint32(34661)},
			{Name: "GL_BUFFER_USAGE_ARB", Value: uint32(34661)},
			{Name: "GL_OBJECT_BUFFER_USAGE_ATI", Value: uint32(34661)},
			{Name: "GL_ARRAY_OBJECT_BUFFER_ATI", Value: uint32(34662)},
			{Name: "GL_ARRAY_OBJECT_OFFSET_ATI", Value: uint32(34663)},
			{Name: "GL_ELEMENT_ARRAY_ATI", Value: uint32(34664)},
			{Name: "GL_ELEMENT_ARRAY_TYPE_ATI", Value: uint32(34665)},
			{Name: "GL_ELEMENT_ARRAY_POINTER_ATI", Value: uint32(34666)},
			{Name: "GL_MAX_VERTEX_STREAMS_ATI", Value: uint32(34667)},
			{Name: "GL_VERTEX_STREAM0_ATI", Value: uint32(34668)},
			{Name: "GL_VERTEX_STREAM1_ATI", Value: uint32(34669)},
			{Name: "GL_VERTEX_STREAM2_ATI", Value: uint32(34670)},
			{Name: "GL_VERTEX_STREAM3_ATI", Value: uint32(34671)},
			{Name: "GL_VERTEX_STREAM4_ATI", Value: uint32(34672)},
			{Name: "GL_VERTEX_STREAM5_ATI", Value: uint32(34673)},
			{Name: "GL_VERTEX_STREAM6_ATI", Value: uint32(34674)},
			{Name: "GL_VERTEX_STREAM7_ATI", Value: uint32(34675)},
			{Name: "GL_VERTEX_SOURCE_ATI", Value: uint32(34676)},
			{Name: "GL_BUMP_ROT_MATRIX_ATI", Value: uint32(34677)},
			{Name: "GL_BUMP_ROT_MATRIX_SIZE_ATI", Value: uint32(34678)},
			{Name: "GL_BUMP_NUM_TEX_UNITS_ATI", Value: uint32(34679)},
			{Name: "GL_BUMP_TEX_UNITS_ATI", Value: uint32(34680)},
			{Name: "GL_DUDV_ATI", Value: uint32(34681)},
			{Name: "GL_DU8DV8_ATI", Value: uint32(34682)},
			{Name: "GL_BUMP_ENVMAP_ATI", Value: uint32(34683)},
			{Name: "GL_BUMP_TARGET_ATI", Value: uint32(34684)},
			{Name: "GL_VERTEX_SHADER_EXT", Value: uint32(34688)},
			{Name: "GL_VERTEX_SHADER_BINDING_EXT", Value: uint32(34689)},
			{Name: "GL_OP_INDEX_EXT", Value: uint32(34690)},
			{Name: "GL_OP_NEGATE_EXT", Value: uint32(34691)},
			{Name: "GL_OP_DOT3_EXT", Value: uint32(34692)},
			{Name: "GL_OP_DOT4_EXT", Value: uint32(34693)},
			{Name: "GL_OP_MUL_EXT", Value: uint32(34694)},
			{Name: "GL_OP_ADD_EXT", Value: uint32(34695)},
			{Name: "GL_OP_MADD_EXT", Value: uint32(34696)},
			{Name: "GL_OP_FRAC_EXT", Value: uint32(34697)},
			{Name: "GL_OP_MAX_EXT", Value: uint32(34698)},
			{Name: "GL_OP_MIN_EXT", Value: uint32(34699)},
			{Name: "GL_OP_SET_GE_EXT", Value: uint32(34700)},
			{Name: "GL_OP_SET_LT_EXT", Value: uint32(34701)},
			{Name: "GL_OP_CLAMP_EXT", Value: uint32(34702)},
			{Name: "GL_OP_FLOOR_EXT", Value: uint32(34703)},
			{Name: "GL_OP_ROUND_EXT", Value: uint32(34704)},
			{Name: "GL_OP_EXP_BASE_2_EXT", Value: uint32(34705)},
			{Name: "GL_OP_LOG_BASE_2_EXT", Value: uint32(34706)},
			{Name: "GL_OP_POWER_EXT", Value: uint32(34707)},
			{Name: "GL_OP_RECIP_EXT", Value: uint32(34708)},
			{Name: "GL_OP_RECIP_SQRT_EXT", Value: uint32(34709)},
			{Name: "GL_OP_SUB_EXT", Value: uint32(34710)},
			{Name: "GL_OP_CROSS_PRODUCT_EXT", Value: uint32(34711)},
			{Name: "GL_OP_MULTIPLY_MATRIX_EXT", Value: uint32(34712)},
			{Name: "GL_OP_MOV_EXT", Value: uint32(34713)},
			{Name: "GL_OUTPUT_VERTEX_EXT", Value: uint32(34714)},
			{Name: "GL_OUTPUT_COLOR0_EXT", Value: uint32(34715)},
			{Name: "GL_OUTPUT_COLOR1_EXT", Value: uint32(34716)},
			{Name: "GL_OUTPUT_TEXTURE_COORD0_EXT", Value: uint32(34717)},
			{Name: "GL_OUTPUT_TEXTURE_COORD1_EXT", Value: uint32(34718)},
			{Name: "GL_OUTPUT_TEXTURE_COORD2_EXT", Value: uint32(34719)},
			{Name: "GL_OUTPUT_TEXTURE_COORD3_EXT", Value: uint32(34720)},
			{Name: "GL_OUTPUT_TEXTURE_COORD4_EXT", Value: uint32(34721)},
			{Name: "GL_OUTPUT_TEXTURE_COORD5_EXT", Value: uint32(34722)},
			{Name: "GL_OUTPUT_TEXTURE_COORD6_EXT", Value: uint32(34723)},
			{Name: "GL_OUTPUT_TEXTURE_COORD7_EXT", Value: uint32(34724)},
			{Name: "GL_OUTPUT_TEXTURE_COORD8_EXT", Value: uint32(34725)},
			{Name: "GL_OUTPUT_TEXTURE_COORD9_EXT", Value: uint32(34726)},
			{Name: "GL_OUTPUT_TEXTURE_COORD10_EXT", Value: uint32(34727)},
			{Name: "GL_OUTPUT_TEXTURE_COORD11_EXT", Value: uint32(34728)},
			{Name: "GL_OUTPUT_TEXTURE_COORD12_EXT", Value: uint32(34729)},
			{Name: "GL_OUTPUT_TEXTURE_COORD13_EXT", Value: uint32(34730)},
			{Name: "GL_OUTPUT_TEXTURE_COORD14_EXT", Value: uint32(34731)},
			{Name: "GL_OUTPUT_TEXTURE_COORD15_EXT", Value: uint32(34732)},
			{Name: "GL_OUTPUT_TEXTURE_COORD16_EXT", Value: uint32(34733)},
			{Name: "GL_OUTPUT_TEXTURE_COORD17_EXT", Value: uint32(34734)},
			{Name: "GL_OUTPUT_TEXTURE_COORD18_EXT", Value: uint32(34735)},
			{Name: "GL_OUTPUT_TEXTURE_COORD19_EXT", Value: uint32(34736)},
			{Name: "GL_OUTPUT_TEXTURE_COORD20_EXT", Value: uint32(34737)},
			{Name: "GL_OUTPUT_TEXTURE_COORD21_EXT", Value: uint32(34738)},
			{Name: "GL_OUTPUT_TEXTURE_COORD22_EXT", Value: uint32(34739)},
			{Name: "GL_OUTPUT_TEXTURE_COORD23_EXT", Value: uint32(34740)},
			{Name: "GL_OUTPUT_TEXTURE_COORD24_EXT", Value: uint32(34741)},
			{Name: "GL_OUTPUT_TEXTURE_COORD25_EXT", Value: uint32(34742)},
			{Name: "GL_OUTPUT_TEXTURE_COORD26_EXT", Value: uint32(34743)},
			{Name: "GL_OUTPUT_TEXTURE_COORD27_EXT", Value: uint32(34744)},
			{Name: "GL_OUTPUT_TEXTURE_COORD28_EXT", Value: uint32(34745)},
			{Name: "GL_OUTPUT_TEXTURE_COORD29_EXT", Value: uint32(34746)},
			{Name: "GL_OUTPUT_TEXTURE_COORD30_EXT", Value: uint32(34747)},
			{Name: "GL_OUTPUT_TEXTURE_COORD31_EXT", Value: uint32(34748)},
			{Name: "GL_OUTPUT_FOG_EXT", Value: uint32(34749)},
			{Name: "GL_SCALAR_EXT", Value: uint32(34750)},
			{Name: "GL_VECTOR_EXT", Value: uint32(34751)},
			{Name: "GL_MATRIX_EXT", Value: uint32(34752)},
			{Name: "GL_VARIANT_EXT", Value: uint32(34753)},
			{Name: "GL_INVARIANT_EXT", Value: uint32(34754)},
			{Name: "GL_LOCAL_CONSTANT_EXT", Value: uint32(34755)},
			{Name: "GL_LOCAL_EXT", Value: uint32(34756)},
			{Name: "GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT", Value: uint32(34757)},
			{Name: "GL_MAX_VERTEX_SHADER_VARIANTS_EXT", Value: uint32(34758)},
			{Name: "GL_MAX_VERTEX_SHADER_INVARIANTS_EXT", Value: uint32(34759)},
			{Name: "GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", Value: uint32(34760)},
			{Name: "GL_MAX_VERTEX_SHADER_LOCALS_EXT", Value: uint32(34761)},
			{Name: "GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT", Value: uint32(34762)},
			{Name: "GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT", Value: uint32(34763)},
			{Name: "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", Value: uint32(34764)},
			{Name: "GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT", Value: uint32(34765)},
			{Name: "GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT", Value: uint32(34766)},
			{Name: "GL_VERTEX_SHADER_INSTRUCTIONS_EXT", Value: uint32(34767)},
			{Name: "GL_VERTEX_SHADER_VARIANTS_EXT", Value: uint32(34768)},
			{Name: "GL_VERTEX_SHADER_INVARIANTS_EXT", Value: uint32(34769)},
			{Name: "GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT", Value: uint32(34770)},
			{Name: "GL_VERTEX_SHADER_LOCALS_EXT", Value: uint32(34771)},
			{Name: "GL_VERTEX_SHADER_OPTIMIZED_EXT", Value: uint32(34772)},
			{Name: "GL_X_EXT", Value: uint32(34773)},
			{Name: "GL_Y_EXT", Value: uint32(34774)},
			{Name: "GL_Z_EXT", Value: uint32(34775)},
			{Name: "GL_W_EXT", Value: uint32(34776)},
			{Name: "GL_NEGATIVE_X_EXT", Value: uint32(34777)},
			{Name: "GL_NEGATIVE_Y_EXT", Value: uint32(34778)},
			{Name: "GL_NEGATIVE_Z_EXT", Value: uint32(34779)},
			{Name: "GL_NEGATIVE_W_EXT", Value: uint32(34780)},
			{Name: "GL_ZERO_EXT", Value: uint32(34781)},
			{Name: "GL_ONE_EXT", Value: uint32(34782)},
			{Name: "GL_NEGATIVE_ONE_EXT", Value: uint32(34783)},
			{Name: "GL_NORMALIZED_RANGE_EXT", Value: uint32(34784)},
			{Name: "GL_FULL_RANGE_EXT", Value: uint32(34785)},
			{Name: "GL_CURRENT_VERTEX_EXT", Value: uint32(34786)},
			{Name: "GL_MVP_MATRIX_EXT", Value: uint32(34787)},
			{Name: "GL_VARIANT_VALUE_EXT", Value: uint32(34788)},
			{Name: "GL_VARIANT_DATATYPE_EXT", Value: uint32(34789)},
			{Name: "GL_VARIANT_ARRAY_STRIDE_EXT", Value: uint32(34790)},
			{Name: "GL_VARIANT_ARRAY_TYPE_EXT", Value: uint32(34791)},
			{Name: "GL_VARIANT_ARRAY_EXT", Value: uint32(34792)},
			{Name: "GL_VARIANT_ARRAY_POINTER_EXT", Value: uint32(34793)},
			{Name: "GL_INVARIANT_VALUE_EXT", Value: uint32(34794)},
			{Name: "GL_INVARIANT_DATATYPE_EXT", Value: uint32(34795)},
			{Name: "GL_LOCAL_CONSTANT_VALUE_EXT", Value: uint32(34796)},
			{Name: "GL_LOCAL_CONSTANT_DATATYPE_EXT", Value: uint32(34797)},
			{Name: "GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD", Value: uint32(34798)},
			{Name: "GL_PN_TRIANGLES_ATI", Value: uint32(34800)},
			{Name: "GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI", Value: uint32(34801)},
			{Name: "GL_PN_TRIANGLES_POINT_MODE_ATI", Value: uint32(34802)},
			{Name: "GL_PN_TRIANGLES_NORMAL_MODE_ATI", Value: uint32(34803)},
			{Name: "GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI", Value: uint32(34804)},
			{Name: "GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI", Value: uint32(34805)},
			{Name: "GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI", Value: uint32(34806)},
			{Name: "GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI", Value: uint32(34807)},
			{Name: "GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI", Value: uint32(34808)},
			{Name: "GL_3DC_X_AMD", Value: uint32(34809)},
			{Name: "GL_3DC_XY_AMD", Value: uint32(34810)},
			{Name: "GL_VBO_FREE_MEMORY_ATI", Value: uint32(34811)},
			{Name: "GL_TEXTURE_FREE_MEMORY_ATI", Value: uint32(34812)},
			{Name: "GL_RENDERBUFFER_FREE_MEMORY_ATI", Value: uint32(34813)},
			{Name: "GL_NUM_PROGRAM_BINARY_FORMATS_OES", Value: uint32(34814)},
			{Name: "GL_NUM_PROGRAM_BINARY_FORMATS", Value: uint32(34814)},
			{Name: "GL_PROGRAM_BINARY_FORMATS_OES", Value: uint32(34815)},
			{Name: "GL_PROGRAM_BINARY_FORMATS", Value: uint32(34815)},
			{Name: "GL_STENCIL_BACK_FUNC", Value: uint32(34816)},
			{Name: "GL_STENCIL_BACK_FUNC_ATI", Value: uint32(34816)},
			{Name: "GL_STENCIL_BACK_FAIL", Value: uint32(34817)},
			{Name: "GL_STENCIL_BACK_FAIL_ATI", Value: uint32(34817)},
			{Name: "GL_STENCIL_BACK_PASS_DEPTH_FAIL", Value: uint32(34818)},
			{Name: "GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI", Value: uint32(34818)},
			{Name: "GL_STENCIL_BACK_PASS_DEPTH_PASS", Value: uint32(34819)},
			{Name: "GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI", Value: uint32(34819)},
			{Name: "GL_FRAGMENT_PROGRAM_ARB", Value: uint32(34820)},
			{Name: "GL_PROGRAM_ALU_INSTRUCTIONS_ARB", Value: uint32(34821)},
			{Name: "GL_PROGRAM_TEX_INSTRUCTIONS_ARB", Value: uint32(34822)},
			{Name: "GL_PROGRAM_TEX_INDIRECTIONS_ARB", Value: uint32(34823)},
			{Name: "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB", Value: uint32(34824)},
			{Name: "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB", Value: uint32(34825)},
			{Name: "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB", Value: uint32(34826)},
			{Name: "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB", Value: uint32(34827)},
			{Name: "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB", Value: uint32(34828)},
			{Name: "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB", Value: uint32(34829)},
			{Name: "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB", Value: uint32(34830)},
			{Name: "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB", Value: uint32(34831)},
			{Name: "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB", Value: uint32(34832)},
			{Name: "GL_RGBA32F_ARB", Value: uint32(34836)},
			{Name: "GL_RGBA_FLOAT32_ATI", Value: uint32(34836)},
			{Name: "GL_RGBA_FLOAT32_APPLE", Value: uint32(34836)},
			{Name: "GL_RGBA32F_EXT", Value: uint32(34836)},
			{Name: "GL_RGBA32F", Value: uint32(34836)},
			{Name: "GL_RGB32F_ARB", Value: uint32(34837)},
			{Name: "GL_RGB_FLOAT32_ATI", Value: uint32(34837)},
			{Name: "GL_RGB_FLOAT32_APPLE", Value: uint32(34837)},
			{Name: "GL_RGB32F_EXT", Value: uint32(34837)},
			{Name: "GL_RGB32F", Value: uint32(34837)},
			{Name: "GL_ALPHA_FLOAT32_ATI", Value: uint32(34838)},
			{Name: "GL_ALPHA_FLOAT32_APPLE", Value: uint32(34838)},
			{Name: "GL_ALPHA32F_ARB", Value: uint32(34838)},
			{Name: "GL_ALPHA32F_EXT", Value: uint32(34838)},
			{Name: "GL_INTENSITY32F_ARB", Value: uint32(34839)},
			{Name: "GL_INTENSITY_FLOAT32_APPLE", Value: uint32(34839)},
			{Name: "GL_INTENSITY_FLOAT32_ATI", Value: uint32(34839)},
			{Name: "GL_LUMINANCE32F_EXT", Value: uint32(34840)},
			{Name: "GL_LUMINANCE_FLOAT32_APPLE", Value: uint32(34840)},
			{Name: "GL_LUMINANCE_FLOAT32_ATI", Value: uint32(34840)},
			{Name: "GL_LUMINANCE32F_ARB", Value: uint32(34840)},
			{Name: "GL_LUMINANCE_ALPHA_FLOAT32_ATI", Value: uint32(34841)},
			{Name: "GL_LUMINANCE_ALPHA32F_ARB", Value: uint32(34841)},
			{Name: "GL_LUMINANCE_ALPHA32F_EXT", Value: uint32(34841)},
			{Name: "GL_LUMINANCE_ALPHA_FLOAT32_APPLE", Value: uint32(34841)},
			{Name: "GL_RGBA16F_EXT", Value: uint32(34842)},
			{Name: "GL_RGBA16F_ARB", Value: uint32(34842)},
			{Name: "GL_RGBA16F", Value: uint32(34842)},
			{Name: "GL_RGBA_FLOAT16_ATI", Value: uint32(34842)},
			{Name: "GL_RGBA_FLOAT16_APPLE", Value: uint32(34842)},
			{Name: "GL_RGB_FLOAT16_APPLE", Value: uint32(34843)},
			{Name: "GL_RGB_FLOAT16_ATI", Value: uint32(34843)},
			{Name: "GL_RGB16F", Value: uint32(34843)},
			{Name: "GL_RGB16F_ARB", Value: uint32(34843)},
			{Name: "GL_RGB16F_EXT", Value: uint32(34843)},
			{Name: "GL_ALPHA16F_EXT", Value: uint32(34844)},
			{Name: "GL_ALPHA_FLOAT16_APPLE", Value: uint32(34844)},
			{Name: "GL_ALPHA_FLOAT16_ATI", Value: uint32(34844)},
			{Name: "GL_ALPHA16F_ARB", Value: uint32(34844)},
			{Name: "GL_INTENSITY_FLOAT16_ATI", Value: uint32(34845)},
			{Name: "GL_INTENSITY16F_ARB", Value: uint32(34845)},
			{Name: "GL_INTENSITY_FLOAT16_APPLE", Value: uint32(34845)},
			{Name: "GL_LUMINANCE16F_EXT", Value: uint32(34846)},
			{Name: "GL_LUMINANCE_FLOAT16_ATI", Value: uint32(34846)},
			{Name: "GL_LUMINANCE16F_ARB", Value: uint32(34846)},
			{Name: "GL_LUMINANCE_FLOAT16_APPLE", Value: uint32(34846)},
			{Name: "GL_LUMINANCE_ALPHA16F_EXT", Value: uint32(34847)},
			{Name: "GL_LUMINANCE_ALPHA16F_ARB", Value: uint32(34847)},
			{Name: "GL_LUMINANCE_ALPHA_FLOAT16_APPLE", Value: uint32(34847)},
			{Name: "GL_LUMINANCE_ALPHA_FLOAT16_ATI", Value: uint32(34847)},
			{Name: "GL_RGBA_FLOAT_MODE_ARB", Value: uint32(34848)},
			{Name: "GL_RGBA_FLOAT_MODE_ATI", Value: uint32(34848)},
			{Name: "GL_WRITEONLY_RENDERING_QCOM", Value: uint32(34851)},
			{Name: "GL_MAX_DRAW_BUFFERS", Value: uint32(34852)},
			{Name: "GL_MAX_DRAW_BUFFERS_ATI", Value: uint32(34852)},
			{Name: "GL_MAX_DRAW_BUFFERS_NV", Value: uint32(34852)},
			{Name: "GL_MAX_DRAW_BUFFERS_ARB", Value: uint32(34852)},
			{Name: "GL_MAX_DRAW_BUFFERS_EXT", Value: uint32(34852)},
			{Name: "GL_DRAW_BUFFER0_EXT", Value: uint32(34853)},
			{Name: "GL_DRAW_BUFFER0_ATI", Value: uint32(34853)},
			{Name: "GL_DRAW_BUFFER0_NV", Value: uint32(34853)},
			{Name: "GL_DRAW_BUFFER0", Value: uint32(34853)},
			{Name: "GL_DRAW_BUFFER0_ARB", Value: uint32(34853)},
			{Name: "GL_DRAW_BUFFER1_NV", Value: uint32(34854)},
			{Name: "GL_DRAW_BUFFER1_EXT", Value: uint32(34854)},
			{Name: "GL_DRAW_BUFFER1_ATI", Value: uint32(34854)},
			{Name: "GL_DRAW_BUFFER1_ARB", Value: uint32(34854)},
			{Name: "GL_DRAW_BUFFER1", Value: uint32(34854)},
			{Name: "GL_DRAW_BUFFER2", Value: uint32(34855)},
			{Name: "GL_DRAW_BUFFER2_NV", Value: uint32(34855)},
			{Name: "GL_DRAW_BUFFER2_EXT", Value: uint32(34855)},
			{Name: "GL_DRAW_BUFFER2_ATI", Value: uint32(34855)},
			{Name: "GL_DRAW_BUFFER2_ARB", Value: uint32(34855)},
			{Name: "GL_DRAW_BUFFER3_EXT", Value: uint32(34856)},
			{Name: "GL_DRAW_BUFFER3_ATI", Value: uint32(34856)},
			{Name: "GL_DRAW_BUFFER3_NV", Value: uint32(34856)},
			{Name: "GL_DRAW_BUFFER3_ARB", Value: uint32(34856)},
			{Name: "GL_DRAW_BUFFER3", Value: uint32(34856)},
			{Name: "GL_DRAW_BUFFER4_EXT", Value: uint32(34857)},
			{Name: "GL_DRAW_BUFFER4_NV", Value: uint32(34857)},
			{Name: "GL_DRAW_BUFFER4_ATI", Value: uint32(34857)},
			{Name: "GL_DRAW_BUFFER4_ARB", Value: uint32(34857)},
			{Name: "GL_DRAW_BUFFER4", Value: uint32(34857)},
			{Name: "GL_DRAW_BUFFER5_ATI", Value: uint32(34858)},
			{Name: "GL_DRAW_BUFFER5", Value: uint32(34858)},
			{Name: "GL_DRAW_BUFFER5_ARB", Value: uint32(34858)},
			{Name: "GL_DRAW_BUFFER5_NV", Value: uint32(34858)},
			{Name: "GL_DRAW_BUFFER5_EXT", Value: uint32(34858)},
			{Name: "GL_DRAW_BUFFER6_ATI", Value: uint32(34859)},
			{Name: "GL_DRAW_BUFFER6", Value: uint32(34859)},
			{Name: "GL_DRAW_BUFFER6_ARB", Value: uint32(34859)},
			{Name: "GL_DRAW_BUFFER6_EXT", Value: uint32(34859)},
			{Name: "GL_DRAW_BUFFER6_NV", Value: uint32(34859)},
			{Name: "GL_DRAW_BUFFER7_ATI", Value: uint32(34860)},
			{Name: "GL_DRAW_BUFFER7_ARB", Value: uint32(34860)},
			{Name: "GL_DRAW_BUFFER7", Value: uint32(34860)},
			{Name: "GL_DRAW_BUFFER7_NV", Value: uint32(34860)},
			{Name: "GL_DRAW_BUFFER7_EXT", Value: uint32(34860)},
			{Name: "GL_DRAW_BUFFER8_ATI", Value: uint32(34861)},
			{Name: "GL_DRAW_BUFFER8", Value: uint32(34861)},
			{Name: "GL_DRAW_BUFFER8_ARB", Value: uint32(34861)},
			{Name: "GL_DRAW_BUFFER8_EXT", Value: uint32(34861)},
			{Name: "GL_DRAW_BUFFER8_NV", Value: uint32(34861)},
			{Name: "GL_DRAW_BUFFER9_ATI", Value: uint32(34862)},
			{Name: "GL_DRAW_BUFFER9", Value: uint32(34862)},
			{Name: "GL_DRAW_BUFFER9_EXT", Value: uint32(34862)},
			{Name: "GL_DRAW_BUFFER9_ARB", Value: uint32(34862)},
			{Name: "GL_DRAW_BUFFER9_NV", Value: uint32(34862)},
			{Name: "GL_DRAW_BUFFER10_ARB", Value: uint32(34863)},
			{Name: "GL_DRAW_BUFFER10_EXT", Value: uint32(34863)},
			{Name: "GL_DRAW_BUFFER10_ATI", Value: uint32(34863)},
			{Name: "GL_DRAW_BUFFER10", Value: uint32(34863)},
			{Name: "GL_DRAW_BUFFER10_NV", Value: uint32(34863)},
			{Name: "GL_DRAW_BUFFER11_ARB", Value: uint32(34864)},
			{Name: "GL_DRAW_BUFFER11_EXT", Value: uint32(34864)},
			{Name: "GL_DRAW_BUFFER11_ATI", Value: uint32(34864)},
			{Name: "GL_DRAW_BUFFER11_NV", Value: uint32(34864)},
			{Name: "GL_DRAW_BUFFER11", Value: uint32(34864)},
			{Name: "GL_DRAW_BUFFER12_ATI", Value: uint32(34865)},
			{Name: "GL_DRAW_BUFFER12_ARB", Value: uint32(34865)},
			{Name: "GL_DRAW_BUFFER12", Value: uint32(34865)},
			{Name: "GL_DRAW_BUFFER12_EXT", Value: uint32(34865)},
			{Name: "GL_DRAW_BUFFER12_NV", Value: uint32(34865)},
			{Name: "GL_DRAW_BUFFER13_ARB", Value: uint32(34866)},
			{Name: "GL_DRAW_BUFFER13_EXT", Value: uint32(34866)},
			{Name: "GL_DRAW_BUFFER13", Value: uint32(34866)},
			{Name: "GL_DRAW_BUFFER13_NV", Value: uint32(34866)},
			{Name: "GL_DRAW_BUFFER13_ATI", Value: uint32(34866)},
			{Name: "GL_DRAW_BUFFER14_ATI", Value: uint32(34867)},
			{Name: "GL_DRAW_BUFFER14", Value: uint32(34867)},
			{Name: "GL_DRAW_BUFFER14_ARB", Value: uint32(34867)},
			{Name: "GL_DRAW_BUFFER14_EXT", Value: uint32(34867)},
			{Name: "GL_DRAW_BUFFER14_NV", Value: uint32(34867)},
			{Name: "GL_DRAW_BUFFER15", Value: uint32(34868)},
			{Name: "GL_DRAW_BUFFER15_ARB", Value: uint32(34868)},
			{Name: "GL_DRAW_BUFFER15_EXT", Value: uint32(34868)},
			{Name: "GL_DRAW_BUFFER15_NV", Value: uint32(34868)},
			{Name: "GL_DRAW_BUFFER15_ATI", Value: uint32(34868)},
			{Name: "GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI", Value: uint32(34869)},
			{Name: "GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI", Value: uint32(34871)},
			{Name: "GL_BLEND_EQUATION_ALPHA", Value: uint32(34877)},
			{Name: "GL_BLEND_EQUATION_ALPHA_OES", Value: uint32(34877)},
			{Name: "GL_BLEND_EQUATION_ALPHA_EXT", Value: uint32(34877)},
			{Name: "GL_SUBSAMPLE_DISTANCE_AMD", Value: uint32(34879)},
			{Name: "GL_MATRIX_PALETTE_ARB", Value: uint32(34880)},
			{Name: "GL_MATRIX_PALETTE_OES", Value: uint32(34880)},
			{Name: "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB", Value: uint32(34881)},
			{Name: "GL_MAX_PALETTE_MATRICES_ARB", Value: uint32(34882)},
			{Name: "GL_MAX_PALETTE_MATRICES_OES", Value: uint32(34882)},
			{Name: "GL_CURRENT_PALETTE_MATRIX_ARB", Value: uint32(34883)},
			{Name: "GL_CURRENT_PALETTE_MATRIX_OES", Value: uint32(34883)},
			{Name: "GL_MATRIX_INDEX_ARRAY_OES", Value: uint32(34884)},
			{Name: "GL_MATRIX_INDEX_ARRAY_ARB", Value: uint32(34884)},
			{Name: "GL_CURRENT_MATRIX_INDEX_ARB", Value: uint32(34885)},
			{Name: "GL_MATRIX_INDEX_ARRAY_SIZE_ARB", Value: uint32(34886)},
			{Name: "GL_MATRIX_INDEX_ARRAY_SIZE_OES", Value: uint32(34886)},
			{Name: "GL_MATRIX_INDEX_ARRAY_TYPE_OES", Value: uint32(34887)},
			{Name: "GL_MATRIX_INDEX_ARRAY_TYPE_ARB", Value: uint32(34887)},
			{Name: "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB", Value: uint32(34888)},
			{Name: "GL_MATRIX_INDEX_ARRAY_STRIDE_OES", Value: uint32(34888)},
			{Name: "GL_MATRIX_INDEX_ARRAY_POINTER_OES", Value: uint32(34889)},
			{Name: "GL_MATRIX_INDEX_ARRAY_POINTER_ARB", Value: uint32(34889)},
			{Name: "GL_TEXTURE_DEPTH_SIZE", Value: uint32(34890)},
			{Name: "GL_TEXTURE_DEPTH_SIZE_ARB", Value: uint32(34890)},
			{Name: "GL_DEPTH_TEXTURE_MODE_ARB", Value: uint32(34891)},
			{Name: "GL_DEPTH_TEXTURE_MODE", Value: uint32(34891)},
			{Name: "GL_TEXTURE_COMPARE_MODE", Value: uint32(34892)},
			{Name: "GL_TEXTURE_COMPARE_MODE_ARB", Value: uint32(34892)},
			{Name: "GL_TEXTURE_COMPARE_MODE_EXT", Value: uint32(34892)},
			{Name: "GL_TEXTURE_COMPARE_FUNC", Value: uint32(34893)},
			{Name: "GL_TEXTURE_COMPARE_FUNC_EXT", Value: uint32(34893)},
			{Name: "GL_TEXTURE_COMPARE_FUNC_ARB", Value: uint32(34893)},
			{Name: "GL_COMPARE_REF_TO_TEXTURE", Value: uint32(34894)},
			{Name: "GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT", Value: uint32(34894)},
			{Name: "GL_COMPARE_REF_TO_TEXTURE_EXT", Value: uint32(34894)},
			{Name: "GL_COMPARE_R_TO_TEXTURE", Value: uint32(34894)},
			{Name: "GL_COMPARE_R_TO_TEXTURE_ARB", Value: uint32(34894)},
			{Name: "GL_TEXTURE_CUBE_MAP_SEAMLESS", Value: uint32(34895)},
			{Name: "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV", Value: uint32(34896)},
			{Name: "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV", Value: uint32(34897)},
			{Name: "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV", Value: uint32(34898)},
			{Name: "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV", Value: uint32(34899)},
			{Name: "GL_OFFSET_HILO_TEXTURE_2D_NV", Value: uint32(34900)},
			{Name: "GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV", Value: uint32(34901)},
			{Name: "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV", Value: uint32(34902)},
			{Name: "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV", Value: uint32(34903)},
			{Name: "GL_DEPENDENT_HILO_TEXTURE_2D_NV", Value: uint32(34904)},
			{Name: "GL_DEPENDENT_RGB_TEXTURE_3D_NV", Value: uint32(34905)},
			{Name: "GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV", Value: uint32(34906)},
			{Name: "GL_DOT_PRODUCT_PASS_THROUGH_NV", Value: uint32(34907)},
			{Name: "GL_DOT_PRODUCT_TEXTURE_1D_NV", Value: uint32(34908)},
			{Name: "GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV", Value: uint32(34909)},
			{Name: "GL_HILO8_NV", Value: uint32(34910)},
			{Name: "GL_SIGNED_HILO8_NV", Value: uint32(34911)},
			{Name: "GL_FORCE_BLUE_TO_ONE_NV", Value: uint32(34912)},
			{Name: "GL_POINT_SPRITE_OES", Value: uint32(34913)},
			{Name: "GL_POINT_SPRITE_ARB", Value: uint32(34913)},
			{Name: "GL_POINT_SPRITE", Value: uint32(34913)},
			{Name: "GL_POINT_SPRITE_NV", Value: uint32(34913)},
			{Name: "GL_COORD_REPLACE_ARB", Value: uint32(34914)},
			{Name: "GL_COORD_REPLACE_OES", Value: uint32(34914)},
			{Name: "GL_COORD_REPLACE", Value: uint32(34914)},
			{Name: "GL_COORD_REPLACE_NV", Value: uint32(34914)},
			{Name: "GL_POINT_SPRITE_R_MODE_NV", Value: uint32(34915)},
			{Name: "GL_PIXEL_COUNTER_BITS_NV", Value: uint32(34916)},
			{Name: "GL_QUERY_COUNTER_BITS_ARB", Value: uint32(34916)},
			{Name: "GL_QUERY_COUNTER_BITS_EXT", Value: uint32(34916)},
			{Name: "GL_QUERY_COUNTER_BITS", Value: uint32(34916)},
			{Name: "GL_CURRENT_OCCLUSION_QUERY_ID_NV", Value: uint32(34917)},
			{Name: "GL_CURRENT_QUERY", Value: uint32(34917)},
			{Name: "GL_CURRENT_QUERY_ARB", Value: uint32(34917)},
			{Name: "GL_CURRENT_QUERY_EXT", Value: uint32(34917)},
			{Name: "GL_QUERY_RESULT_ARB", Value: uint32(34918)},
			{Name: "GL_QUERY_RESULT", Value: uint32(34918)},
			{Name: "GL_PIXEL_COUNT_NV", Value: uint32(34918)},
			{Name: "GL_QUERY_RESULT_EXT", Value: uint32(34918)},
			{Name: "GL_PIXEL_COUNT_AVAILABLE_NV", Value: uint32(34919)},
			{Name: "GL_QUERY_RESULT_AVAILABLE_ARB", Value: uint32(34919)},
			{Name: "GL_QUERY_RESULT_AVAILABLE_EXT", Value: uint32(34919)},
			{Name: "GL_QUERY_RESULT_AVAILABLE", Value: uint32(34919)},
			{Name: "GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV", Value: uint32(34920)},
			{Name: "GL_MAX_VERTEX_ATTRIBS", Value: uint32(34921)},
			{Name: "GL_MAX_VERTEX_ATTRIBS_ARB", Value: uint32(34921)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB", Value: uint32(34922)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED", Value: uint32(34922)},
			{Name: "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT", Value: uint32(34924)},
			{Name: "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES", Value: uint32(34924)},
			{Name: "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS", Value: uint32(34924)},
			{Name: "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES", Value: uint32(34925)},
			{Name: "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT", Value: uint32(34925)},
			{Name: "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS", Value: uint32(34925)},
			{Name: "GL_DEPTH_STENCIL_TO_RGBA_NV", Value: uint32(34926)},
			{Name: "GL_DEPTH_STENCIL_TO_BGRA_NV", Value: uint32(34927)},
			{Name: "GL_FRAGMENT_PROGRAM_NV", Value: uint32(34928)},
			{Name: "GL_MAX_TEXTURE_COORDS", Value: uint32(34929)},
			{Name: "GL_MAX_TEXTURE_COORDS_ARB", Value: uint32(34929)},
			{Name: "GL_MAX_TEXTURE_COORDS_NV", Value: uint32(34929)},
			{Name: "GL_MAX_TEXTURE_IMAGE_UNITS", Value: uint32(34930)},
			{Name: "GL_MAX_TEXTURE_IMAGE_UNITS_NV", Value: uint32(34930)},
			{Name: "GL_MAX_TEXTURE_IMAGE_UNITS_ARB", Value: uint32(34930)},
			{Name: "GL_FRAGMENT_PROGRAM_BINDING_NV", Value: uint32(34931)},
			{Name: "GL_PROGRAM_ERROR_STRING_ARB", Value: uint32(34932)},
			{Name: "GL_PROGRAM_ERROR_STRING_NV", Value: uint32(34932)},
			{Name: "GL_PROGRAM_FORMAT_ASCII_ARB", Value: uint32(34933)},
			{Name: "GL_PROGRAM_FORMAT_ARB", Value: uint32(34934)},
			{Name: "GL_WRITE_PIXEL_DATA_RANGE_NV", Value: uint32(34936)},
			{Name: "GL_READ_PIXEL_DATA_RANGE_NV", Value: uint32(34937)},
			{Name: "GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV", Value: uint32(34938)},
			{Name: "GL_READ_PIXEL_DATA_RANGE_LENGTH_NV", Value: uint32(34939)},
			{Name: "GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV", Value: uint32(34940)},
			{Name: "GL_READ_PIXEL_DATA_RANGE_POINTER_NV", Value: uint32(34941)},
			{Name: "GL_GEOMETRY_SHADER_INVOCATIONS_OES", Value: uint32(34943)},
			{Name: "GL_GEOMETRY_SHADER_INVOCATIONS", Value: uint32(34943)},
			{Name: "GL_GEOMETRY_SHADER_INVOCATIONS_EXT", Value: uint32(34943)},
			{Name: "GL_FLOAT_R_NV", Value: uint32(34944)},
			{Name: "GL_FLOAT_RG_NV", Value: uint32(34945)},
			{Name: "GL_FLOAT_RGB_NV", Value: uint32(34946)},
			{Name: "GL_FLOAT_RGBA_NV", Value: uint32(34947)},
			{Name: "GL_FLOAT_R16_NV", Value: uint32(34948)},
			{Name: "GL_FLOAT_R32_NV", Value: uint32(34949)},
			{Name: "GL_FLOAT_RG16_NV", Value: uint32(34950)},
			{Name: "GL_FLOAT_RG32_NV", Value: uint32(34951)},
			{Name: "GL_FLOAT_RGB16_NV", Value: uint32(34952)},
			{Name: "GL_FLOAT_RGB32_NV", Value: uint32(34953)},
			{Name: "GL_FLOAT_RGBA16_NV", Value: uint32(34954)},
			{Name: "GL_FLOAT_RGBA32_NV", Value: uint32(34955)},
			{Name: "GL_TEXTURE_FLOAT_COMPONENTS_NV", Value: uint32(34956)},
			{Name: "GL_FLOAT_CLEAR_COLOR_VALUE_NV", Value: uint32(34957)},
			{Name: "GL_FLOAT_RGBA_MODE_NV", Value: uint32(34958)},
			{Name: "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV", Value: uint32(34959)},
			{Name: "GL_DEPTH_BOUNDS_TEST_EXT", Value: uint32(34960)},
			{Name: "GL_DEPTH_BOUNDS_EXT", Value: uint32(34961)},
			{Name: "GL_ARRAY_BUFFER_ARB", Value: uint32(34962)},
			{Name: "GL_ARRAY_BUFFER", Value: uint32(34962)},
			{Name: "GL_ELEMENT_ARRAY_BUFFER_ARB", Value: uint32(34963)},
			{Name: "GL_ELEMENT_ARRAY_BUFFER", Value: uint32(34963)},
			{Name: "GL_ARRAY_BUFFER_BINDING", Value: uint32(34964)},
			{Name: "GL_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34964)},
			{Name: "GL_ELEMENT_ARRAY_BUFFER_BINDING", Value: uint32(34965)},
			{Name: "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34965)},
			{Name: "GL_VERTEX_ARRAY_BUFFER_BINDING", Value: uint32(34966)},
			{Name: "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34966)},
			{Name: "GL_NORMAL_ARRAY_BUFFER_BINDING", Value: uint32(34967)},
			{Name: "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34967)},
			{Name: "GL_COLOR_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34968)},
			{Name: "GL_COLOR_ARRAY_BUFFER_BINDING", Value: uint32(34968)},
			{Name: "GL_INDEX_ARRAY_BUFFER_BINDING", Value: uint32(34969)},
			{Name: "GL_INDEX_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34969)},
			{Name: "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34970)},
			{Name: "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING", Value: uint32(34970)},
			{Name: "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING", Value: uint32(34971)},
			{Name: "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34971)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING", Value: uint32(34972)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34972)},
			{Name: "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34973)},
			{Name: "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING", Value: uint32(34973)},
			{Name: "GL_FOG_COORD_ARRAY_BUFFER_BINDING", Value: uint32(34973)},
			{Name: "GL_WEIGHT_ARRAY_BUFFER_BINDING_OES", Value: uint32(34974)},
			{Name: "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34974)},
			{Name: "GL_WEIGHT_ARRAY_BUFFER_BINDING", Value: uint32(34974)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", Value: uint32(34975)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB", Value: uint32(34975)},
			{Name: "GL_PROGRAM_INSTRUCTIONS_ARB", Value: uint32(34976)},
			{Name: "GL_MAX_PROGRAM_INSTRUCTIONS_ARB", Value: uint32(34977)},
			{Name: "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB", Value: uint32(34978)},
			{Name: "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB", Value: uint32(34979)},
			{Name: "GL_PROGRAM_TEMPORARIES_ARB", Value: uint32(34980)},
			{Name: "GL_MAX_PROGRAM_TEMPORARIES_ARB", Value: uint32(34981)},
			{Name: "GL_PROGRAM_NATIVE_TEMPORARIES_ARB", Value: uint32(34982)},
			{Name: "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB", Value: uint32(34983)},
			{Name: "GL_PROGRAM_PARAMETERS_ARB", Value: uint32(34984)},
			{Name: "GL_MAX_PROGRAM_PARAMETERS_ARB", Value: uint32(34985)},
			{Name: "GL_PROGRAM_NATIVE_PARAMETERS_ARB", Value: uint32(34986)},
			{Name: "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB", Value: uint32(34987)},
			{Name: "GL_PROGRAM_ATTRIBS_ARB", Value: uint32(34988)},
			{Name: "GL_MAX_PROGRAM_ATTRIBS_ARB", Value: uint32(34989)},
			{Name: "GL_PROGRAM_NATIVE_ATTRIBS_ARB", Value: uint32(34990)},
			{Name: "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB", Value: uint32(34991)},
			{Name: "GL_PROGRAM_ADDRESS_REGISTERS_ARB", Value: uint32(34992)},
			{Name: "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB", Value: uint32(34993)},
			{Name: "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB", Value: uint32(34994)},
			{Name: "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB", Value: uint32(34995)},
			{Name: "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB", Value: uint32(34996)},
			{Name: "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB", Value: uint32(34997)},
			{Name: "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB", Value: uint32(34998)},
			{Name: "GL_TRANSPOSE_CURRENT_MATRIX_ARB", Value: uint32(34999)},
			{Name: "GL_READ_ONLY_ARB", Value: uint32(35000)},
			{Name: "GL_READ_ONLY", Value: uint32(35000)},
			{Name: "GL_WRITE_ONLY", Value: uint32(35001)},
			{Name: "GL_WRITE_ONLY_ARB", Value: uint32(35001)},
			{Name: "GL_WRITE_ONLY_OES", Value: uint32(35001)},
			{Name: "GL_READ_WRITE_ARB", Value: uint32(35002)},
			{Name: "GL_READ_WRITE", Value: uint32(35002)},
			{Name: "GL_BUFFER_ACCESS_ARB", Value: uint32(35003)},
			{Name: "GL_BUFFER_ACCESS_OES", Value: uint32(35003)},
			{Name: "GL_BUFFER_ACCESS", Value: uint32(35003)},
			{Name: "GL_BUFFER_MAPPED", Value: uint32(35004)},
			{Name: "GL_BUFFER_MAPPED_ARB", Value: uint32(35004)},
			{Name: "GL_BUFFER_MAPPED_OES", Value: uint32(35004)},
			{Name: "GL_BUFFER_MAP_POINTER_OES", Value: uint32(35005)},
			{Name: "GL_BUFFER_MAP_POINTER", Value: uint32(35005)},
			{Name: "GL_BUFFER_MAP_POINTER_ARB", Value: uint32(35005)},
			{Name: "GL_WRITE_DISCARD_NV", Value: uint32(35006)},
			{Name: "GL_TIME_ELAPSED", Value: uint32(35007)},
			{Name: "GL_TIME_ELAPSED_EXT", Value: uint32(35007)},
			{Name: "GL_MATRIX0_ARB", Value: uint32(35008)},
			{Name: "GL_MATRIX1_ARB", Value: uint32(35009)},
			{Name: "GL_MATRIX2_ARB", Value: uint32(35010)},
			{Name: "GL_MATRIX3_ARB", Value: uint32(35011)},
			{Name: "GL_MATRIX4_ARB", Value: uint32(35012)},
			{Name: "GL_MATRIX5_ARB", Value: uint32(35013)},
			{Name: "GL_MATRIX6_ARB", Value: uint32(35014)},
			{Name: "GL_MATRIX7_ARB", Value: uint32(35015)},
			{Name: "GL_MATRIX8_ARB", Value: uint32(35016)},
			{Name: "GL_MATRIX9_ARB", Value: uint32(35017)},
			{Name: "GL_MATRIX10_ARB", Value: uint32(35018)},
			{Name: "GL_MATRIX11_ARB", Value: uint32(35019)},
			{Name: "GL_MATRIX12_ARB", Value: uint32(35020)},
			{Name: "GL_MATRIX13_ARB", Value: uint32(35021)},
			{Name: "GL_MATRIX14_ARB", Value: uint32(35022)},
			{Name: "GL_MATRIX15_ARB", Value: uint32(35023)},
			{Name: "GL_MATRIX16_ARB", Value: uint32(35024)},
			{Name: "GL_MATRIX17_ARB", Value: uint32(35025)},
			{Name: "GL_MATRIX18_ARB", Value: uint32(35026)},
			{Name: "GL_MATRIX19_ARB", Value: uint32(35027)},
			{Name: "GL_MATRIX20_ARB", Value: uint32(35028)},
			{Name: "GL_MATRIX21_ARB", Value: uint32(35029)},
			{Name: "GL_MATRIX22_ARB", Value: uint32(35030)},
			{Name: "GL_MATRIX23_ARB", Value: uint32(35031)},
			{Name: "GL_MATRIX24_ARB", Value: uint32(35032)},
			{Name: "GL_MATRIX25_ARB", Value: uint32(35033)},
			{Name: "GL_MATRIX26_ARB", Value: uint32(35034)},
			{Name: "GL_MATRIX27_ARB", Value: uint32(35035)},
			{Name: "GL_MATRIX28_ARB", Value: uint32(35036)},
			{Name: "GL_MATRIX29_ARB", Value: uint32(35037)},
			{Name: "GL_MATRIX30_ARB", Value: uint32(35038)},
			{Name: "GL_MATRIX31_ARB", Value: uint32(35039)},
			{Name: "GL_STREAM_DRAW_ARB", Value: uint32(35040)},
			{Name: "GL_STREAM_DRAW", Value: uint32(35040)},
			{Name: "GL_STREAM_READ", Value: uint32(35041)},
			{Name: "GL_STREAM_READ_ARB", Value: uint32(35041)},
			{Name: "GL_STREAM_COPY", Value: uint32(35042)},
			{Name: "GL_STREAM_COPY_ARB", Value: uint32(35042)},
			{Name: "GL_STATIC_DRAW", Value: uint32(35044)},
			{Name: "GL_STATIC_DRAW_ARB", Value: uint32(35044)},
			{Name: "GL_STATIC_READ_ARB", Value: uint32(35045)},
			{Name: "GL_STATIC_READ", Value: uint32(35045)},
			{Name: "GL_STATIC_COPY_ARB", Value: uint32(35046)},
			{Name: "GL_STATIC_COPY", Value: uint32(35046)},
			{Name: "GL_DYNAMIC_DRAW_ARB", Value: uint32(35048)},
			{Name: "GL_DYNAMIC_DRAW", Value: uint32(35048)},
			{Name: "GL_DYNAMIC_READ_ARB", Value: uint32(35049)},
			{Name: "GL_DYNAMIC_READ", Value: uint32(35049)},
			{Name: "GL_DYNAMIC_COPY_ARB", Value: uint32(35050)},
			{Name: "GL_DYNAMIC_COPY", Value: uint32(35050)},
			{Name: "GL_PIXEL_PACK_BUFFER_ARB", Value: uint32(35051)},
			{Name: "GL_PIXEL_PACK_BUFFER", Value: uint32(35051)},
			{Name: "GL_PIXEL_PACK_BUFFER_EXT", Value: uint32(35051)},
			{Name: "GL_PIXEL_UNPACK_BUFFER_EXT", Value: uint32(35052)},
			{Name: "GL_PIXEL_UNPACK_BUFFER_ARB", Value: uint32(35052)},
			{Name: "GL_PIXEL_UNPACK_BUFFER", Value: uint32(35052)},
			{Name: "GL_PIXEL_PACK_BUFFER_BINDING_EXT", Value: uint32(35053)},
			{Name: "GL_PIXEL_PACK_BUFFER_BINDING", Value: uint32(35053)},
			{Name: "GL_PIXEL_PACK_BUFFER_BINDING_ARB", Value: uint32(35053)},
			{Name: "GL_ETC1_SRGB8_NV", Value: uint32(35054)},
			{Name: "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT", Value: uint32(35055)},
			{Name: "GL_PIXEL_UNPACK_BUFFER_BINDING_ARB", Value: uint32(35055)},
			{Name: "GL_PIXEL_UNPACK_BUFFER_BINDING", Value: uint32(35055)},
			{Name: "GL_DEPTH24_STENCIL8_OES", Value: uint32(35056)},
			{Name: "GL_DEPTH24_STENCIL8", Value: uint32(35056)},
			{Name: "GL_DEPTH24_STENCIL8_EXT", Value: uint32(35056)},
			{Name: "GL_TEXTURE_STENCIL_SIZE_EXT", Value: uint32(35057)},
			{Name: "GL_TEXTURE_STENCIL_SIZE", Value: uint32(35057)},
			{Name: "GL_STENCIL_TAG_BITS_EXT", Value: uint32(35058)},
			{Name: "GL_STENCIL_CLEAR_TAG_VALUE_EXT", Value: uint32(35059)},
			{Name: "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV", Value: uint32(35060)},
			{Name: "GL_MAX_PROGRAM_CALL_DEPTH_NV", Value: uint32(35061)},
			{Name: "GL_MAX_PROGRAM_IF_DEPTH_NV", Value: uint32(35062)},
			{Name: "GL_MAX_PROGRAM_LOOP_DEPTH_NV", Value: uint32(35063)},
			{Name: "GL_MAX_PROGRAM_LOOP_COUNT_NV", Value: uint32(35064)},
			{Name: "GL_SRC1_COLOR", Value: uint32(35065)},
			{Name: "GL_ONE_MINUS_SRC1_COLOR", Value: uint32(35066)},
			{Name: "GL_ONE_MINUS_SRC1_ALPHA", Value: uint32(35067)},
			{Name: "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS", Value: uint32(35068)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV", Value: uint32(35069)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT", Value: uint32(35069)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_INTEGER", Value: uint32(35069)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE", Value: uint32(35070)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB", Value: uint32(35070)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV", Value: uint32(35070)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_DIVISOR", Value: uint32(35070)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT", Value: uint32(35070)},
			{Name: "GL_MAX_ARRAY_TEXTURE_LAYERS", Value: uint32(35071)},
			{Name: "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT", Value: uint32(35071)},
			{Name: "GL_MIN_PROGRAM_TEXEL_OFFSET", Value: uint32(35076)},
			{Name: "GL_MIN_PROGRAM_TEXEL_OFFSET_EXT", Value: uint32(35076)},
			{Name: "GL_MIN_PROGRAM_TEXEL_OFFSET_NV", Value: uint32(35076)},
			{Name: "GL_MAX_PROGRAM_TEXEL_OFFSET_NV", Value: uint32(35077)},
			{Name: "GL_MAX_PROGRAM_TEXEL_OFFSET", Value: uint32(35077)},
			{Name: "GL_MAX_PROGRAM_TEXEL_OFFSET_EXT", Value: uint32(35077)},
			{Name: "GL_PROGRAM_ATTRIB_COMPONENTS_NV", Value: uint32(35078)},
			{Name: "GL_PROGRAM_RESULT_COMPONENTS_NV", Value: uint32(35079)},
			{Name: "GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV", Value: uint32(35080)},
			{Name: "GL_MAX_PROGRAM_RESULT_COMPONENTS_NV", Value: uint32(35081)},
			{Name: "GL_STENCIL_TEST_TWO_SIDE_EXT", Value: uint32(35088)},
			{Name: "GL_ACTIVE_STENCIL_FACE_EXT", Value: uint32(35089)},
			{Name: "GL_MIRROR_CLAMP_TO_BORDER_EXT", Value: uint32(35090)},
			{Name: "GL_SAMPLES_PASSED", Value: uint32(35092)},
			{Name: "GL_SAMPLES_PASSED_ARB", Value: uint32(35092)},
			{Name: "GL_GEOMETRY_VERTICES_OUT", Value: uint32(35094)},
			{Name: "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT", Value: uint32(35094)},
			{Name: "GL_GEOMETRY_LINKED_VERTICES_OUT_OES", Value: uint32(35094)},
			{Name: "GL_GEOMETRY_INPUT_TYPE", Value: uint32(35095)},
			{Name: "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT", Value: uint32(35095)},
			{Name: "GL_GEOMETRY_LINKED_INPUT_TYPE_OES", Value: uint32(35095)},
			{Name: "GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES", Value: uint32(35096)},
			{Name: "GL_GEOMETRY_OUTPUT_TYPE", Value: uint32(35096)},
			{Name: "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT", Value: uint32(35096)},
			{Name: "GL_SAMPLER_BINDING", Value: uint32(35097)},
			{Name: "GL_CLAMP_VERTEX_COLOR_ARB", Value: uint32(35098)},
			{Name: "GL_CLAMP_VERTEX_COLOR", Value: uint32(35098)},
			{Name: "GL_CLAMP_FRAGMENT_COLOR", Value: uint32(35099)},
			{Name: "GL_CLAMP_FRAGMENT_COLOR_ARB", Value: uint32(35099)},
			{Name: "GL_CLAMP_READ_COLOR_ARB", Value: uint32(35100)},
			{Name: "GL_CLAMP_READ_COLOR", Value: uint32(35100)},
			{Name: "GL_FIXED_ONLY_ARB", Value: uint32(35101)},
			{Name: "GL_FIXED_ONLY", Value: uint32(35101)},
			{Name: "GL_TESS_CONTROL_PROGRAM_NV", Value: uint32(35102)},
			{Name: "GL_TESS_EVALUATION_PROGRAM_NV", Value: uint32(35103)},
			{Name: "GL_FRAGMENT_SHADER_ATI", Value: uint32(35104)},
			{Name: "GL_REG_0_ATI", Value: uint32(35105)},
			{Name: "GL_REG_1_ATI", Value: uint32(35106)},
			{Name: "GL_REG_2_ATI", Value: uint32(35107)},
			{Name: "GL_REG_3_ATI", Value: uint32(35108)},
			{Name: "GL_REG_4_ATI", Value: uint32(35109)},
			{Name: "GL_REG_5_ATI", Value: uint32(35110)},
			{Name: "GL_REG_6_ATI", Value: uint32(35111)},
			{Name: "GL_REG_7_ATI", Value: uint32(35112)},
			{Name: "GL_REG_8_ATI", Value: uint32(35113)},
			{Name: "GL_REG_9_ATI", Value: uint32(35114)},
			{Name: "GL_REG_10_ATI", Value: uint32(35115)},
			{Name: "GL_REG_11_ATI", Value: uint32(35116)},
			{Name: "GL_REG_12_ATI", Value: uint32(35117)},
			{Name: "GL_REG_13_ATI", Value: uint32(35118)},
			{Name: "GL_REG_14_ATI", Value: uint32(35119)},
			{Name: "GL_REG_15_ATI", Value: uint32(35120)},
			{Name: "GL_REG_16_ATI", Value: uint32(35121)},
			{Name: "GL_REG_17_ATI", Value: uint32(35122)},
			{Name: "GL_REG_18_ATI", Value: uint32(35123)},
			{Name: "GL_REG_19_ATI", Value: uint32(35124)},
			{Name: "GL_REG_20_ATI", Value: uint32(35125)},
			{Name: "GL_REG_21_ATI", Value: uint32(35126)},
			{Name: "GL_REG_22_ATI", Value: uint32(35127)},
			{Name: "GL_REG_23_ATI", Value: uint32(35128)},
			{Name: "GL_REG_24_ATI", Value: uint32(35129)},
			{Name: "GL_REG_25_ATI", Value: uint32(35130)},
			{Name: "GL_REG_26_ATI", Value: uint32(35131)},
			{Name: "GL_REG_27_ATI", Value: uint32(35132)},
			{Name: "GL_REG_28_ATI", Value: uint32(35133)},
			{Name: "GL_REG_29_ATI", Value: uint32(35134)},
			{Name: "GL_REG_30_ATI", Value: uint32(35135)},
			{Name: "GL_REG_31_ATI", Value: uint32(35136)},
			{Name: "GL_CON_0_ATI", Value: uint32(35137)},
			{Name: "GL_CON_1_ATI", Value: uint32(35138)},
			{Name: "GL_CON_2_ATI", Value: uint32(35139)},
			{Name: "GL_CON_3_ATI", Value: uint32(35140)},
			{Name: "GL_CON_4_ATI", Value: uint32(35141)},
			{Name: "GL_CON_5_ATI", Value: uint32(35142)},
			{Name: "GL_CON_6_ATI", Value: uint32(35143)},
			{Name: "GL_CON_7_ATI", Value: uint32(35144)},
			{Name: "GL_CON_8_ATI", Value: uint32(35145)},
			{Name: "GL_CON_9_ATI", Value: uint32(35146)},
			{Name: "GL_CON_10_ATI", Value: uint32(35147)},
			{Name: "GL_CON_11_ATI", Value: uint32(35148)},
			{Name: "GL_CON_12_ATI", Value: uint32(35149)},
			{Name: "GL_CON_13_ATI", Value: uint32(35150)},
			{Name: "GL_CON_14_ATI", Value: uint32(35151)},
			{Name: "GL_CON_15_ATI", Value: uint32(35152)},
			{Name: "GL_CON_16_ATI", Value: uint32(35153)},
			{Name: "GL_CON_17_ATI", Value: uint32(35154)},
			{Name: "GL_CON_18_ATI", Value: uint32(35155)},
			{Name: "GL_CON_19_ATI", Value: uint32(35156)},
			{Name: "GL_CON_20_ATI", Value: uint32(35157)},
			{Name: "GL_CON_21_ATI", Value: uint32(35158)},
			{Name: "GL_CON_22_ATI", Value: uint32(35159)},
			{Name: "GL_CON_23_ATI", Value: uint32(35160)},
			{Name: "GL_CON_24_ATI", Value: uint32(35161)},
			{Name: "GL_CON_25_ATI", Value: uint32(35162)},
			{Name: "GL_CON_26_ATI", Value: uint32(35163)},
			{Name: "GL_CON_27_ATI", Value: uint32(35164)},
			{Name: "GL_CON_28_ATI", Value: uint32(35165)},
			{Name: "GL_CON_29_ATI", Value: uint32(35166)},
			{Name: "GL_CON_30_ATI", Value: uint32(35167)},
			{Name: "GL_CON_31_ATI", Value: uint32(35168)},
			{Name: "GL_MOV_ATI", Value: uint32(35169)},
			{Name: "GL_ADD_ATI", Value: uint32(35171)},
			{Name: "GL_MUL_ATI", Value: uint32(35172)},
			{Name: "GL_SUB_ATI", Value: uint32(35173)},
			{Name: "GL_DOT3_ATI", Value: uint32(35174)},
			{Name: "GL_DOT4_ATI", Value: uint32(35175)},
			{Name: "GL_MAD_ATI", Value: uint32(35176)},
			{Name: "GL_LERP_ATI", Value: uint32(35177)},
			{Name: "GL_CND_ATI", Value: uint32(35178)},
			{Name: "GL_CND0_ATI", Value: uint32(35179)},
			{Name: "GL_DOT2_ADD_ATI", Value: uint32(35180)},
			{Name: "GL_SECONDARY_INTERPOLATOR_ATI", Value: uint32(35181)},
			{Name: "GL_NUM_FRAGMENT_REGISTERS_ATI", Value: uint32(35182)},
			{Name: "GL_NUM_FRAGMENT_CONSTANTS_ATI", Value: uint32(35183)},
			{Name: "GL_NUM_PASSES_ATI", Value: uint32(35184)},
			{Name: "GL_NUM_INSTRUCTIONS_PER_PASS_ATI", Value: uint32(35185)},
			{Name: "GL_NUM_INSTRUCTIONS_TOTAL_ATI", Value: uint32(35186)},
			{Name: "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI", Value: uint32(35187)},
			{Name: "GL_NUM_LOOPBACK_COMPONENTS_ATI", Value: uint32(35188)},
			{Name: "GL_COLOR_ALPHA_PAIRING_ATI", Value: uint32(35189)},
			{Name: "GL_SWIZZLE_STR_ATI", Value: uint32(35190)},
			{Name: "GL_SWIZZLE_STQ_ATI", Value: uint32(35191)},
			{Name: "GL_SWIZZLE_STR_DR_ATI", Value: uint32(35192)},
			{Name: "GL_SWIZZLE_STQ_DQ_ATI", Value: uint32(35193)},
			{Name: "GL_SWIZZLE_STRQ_ATI", Value: uint32(35194)},
			{Name: "GL_SWIZZLE_STRQ_DQ_ATI", Value: uint32(35195)},
			{Name: "GL_INTERLACE_OML", Value: uint32(35200)},
			{Name: "GL_INTERLACE_READ_OML", Value: uint32(35201)},
			{Name: "GL_FORMAT_SUBSAMPLE_24_24_OML", Value: uint32(35202)},
			{Name: "GL_FORMAT_SUBSAMPLE_244_244_OML", Value: uint32(35203)},
			{Name: "GL_PACK_RESAMPLE_OML", Value: uint32(35204)},
			{Name: "GL_UNPACK_RESAMPLE_OML", Value: uint32(35205)},
			{Name: "GL_RESAMPLE_REPLICATE_OML", Value: uint32(35206)},
			{Name: "GL_RESAMPLE_ZERO_FILL_OML", Value: uint32(35207)},
			{Name: "GL_RESAMPLE_AVERAGE_OML", Value: uint32(35208)},
			{Name: "GL_RESAMPLE_DECIMATE_OML", Value: uint32(35209)},
			{Name: "GL_POINT_SIZE_ARRAY_TYPE_OES", Value: uint32(35210)},
			{Name: "GL_POINT_SIZE_ARRAY_STRIDE_OES", Value: uint32(35211)},
			{Name: "GL_POINT_SIZE_ARRAY_POINTER_OES", Value: uint32(35212)},
			{Name: "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES", Value: uint32(35213)},
			{Name: "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES", Value: uint32(35214)},
			{Name: "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES", Value: uint32(35215)},
			{Name: "GL_VERTEX_ATTRIB_MAP1_APPLE", Value: uint32(35328)},
			{Name: "GL_VERTEX_ATTRIB_MAP2_APPLE", Value: uint32(35329)},
			{Name: "GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE", Value: uint32(35330)},
			{Name: "GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE", Value: uint32(35331)},
			{Name: "GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE", Value: uint32(35332)},
			{Name: "GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE", Value: uint32(35333)},
			{Name: "GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE", Value: uint32(35334)},
			{Name: "GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE", Value: uint32(35335)},
			{Name: "GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE", Value: uint32(35336)},
			{Name: "GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE", Value: uint32(35337)},
			{Name: "GL_DRAW_PIXELS_APPLE", Value: uint32(35338)},
			{Name: "GL_FENCE_APPLE", Value: uint32(35339)},
			{Name: "GL_ELEMENT_ARRAY_APPLE", Value: uint32(35340)},
			{Name: "GL_ELEMENT_ARRAY_TYPE_APPLE", Value: uint32(35341)},
			{Name: "GL_ELEMENT_ARRAY_POINTER_APPLE", Value: uint32(35342)},
			{Name: "GL_COLOR_FLOAT_APPLE", Value: uint32(35343)},
			{Name: "GL_UNIFORM_BUFFER", Value: uint32(35345)},
			{Name: "GL_BUFFER_SERIALIZED_MODIFY_APPLE", Value: uint32(35346)},
			{Name: "GL_BUFFER_FLUSHING_UNMAP_APPLE", Value: uint32(35347)},
			{Name: "GL_AUX_DEPTH_STENCIL_APPLE", Value: uint32(35348)},
			{Name: "GL_PACK_ROW_BYTES_APPLE", Value: uint32(35349)},
			{Name: "GL_UNPACK_ROW_BYTES_APPLE", Value: uint32(35350)},
			{Name: "GL_RELEASED_APPLE", Value: uint32(35353)},
			{Name: "GL_VOLATILE_APPLE", Value: uint32(35354)},
			{Name: "GL_RETAINED_APPLE", Value: uint32(35355)},
			{Name: "GL_UNDEFINED_APPLE", Value: uint32(35356)},
			{Name: "GL_PURGEABLE_APPLE", Value: uint32(35357)},
			{Name: "GL_RGB_422_APPLE", Value: uint32(35359)},
			{Name: "GL_UNIFORM_BUFFER_BINDING", Value: uint32(35368)},
			{Name: "GL_UNIFORM_BUFFER_START", Value: uint32(35369)},
			{Name: "GL_UNIFORM_BUFFER_SIZE", Value: uint32(35370)},
			{Name: "GL_MAX_VERTEX_UNIFORM_BLOCKS", Value: uint32(35371)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT", Value: uint32(35372)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES", Value: uint32(35372)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_BLOCKS", Value: uint32(35372)},
			{Name: "GL_MAX_FRAGMENT_UNIFORM_BLOCKS", Value: uint32(35373)},
			{Name: "GL_MAX_COMBINED_UNIFORM_BLOCKS", Value: uint32(35374)},
			{Name: "GL_MAX_UNIFORM_BUFFER_BINDINGS", Value: uint32(35375)},
			{Name: "GL_MAX_UNIFORM_BLOCK_SIZE", Value: uint32(35376)},
			{Name: "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", Value: uint32(35377)},
			{Name: "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS", Value: uint32(35378)},
			{Name: "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES", Value: uint32(35378)},
			{Name: "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT", Value: uint32(35378)},
			{Name: "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS", Value: uint32(35379)},
			{Name: "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT", Value: uint32(35380)},
			{Name: "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH", Value: uint32(35381)},
			{Name: "GL_ACTIVE_UNIFORM_BLOCKS", Value: uint32(35382)},
			{Name: "GL_UNIFORM_TYPE", Value: uint32(35383)},
			{Name: "GL_UNIFORM_SIZE", Value: uint32(35384)},
			{Name: "GL_UNIFORM_NAME_LENGTH", Value: uint32(35385)},
			{Name: "GL_UNIFORM_BLOCK_INDEX", Value: uint32(35386)},
			{Name: "GL_UNIFORM_OFFSET", Value: uint32(35387)},
			{Name: "GL_UNIFORM_ARRAY_STRIDE", Value: uint32(35388)},
			{Name: "GL_UNIFORM_MATRIX_STRIDE", Value: uint32(35389)},
			{Name: "GL_UNIFORM_IS_ROW_MAJOR", Value: uint32(35390)},
			{Name: "GL_UNIFORM_BLOCK_BINDING", Value: uint32(35391)},
			{Name: "GL_UNIFORM_BLOCK_DATA_SIZE", Value: uint32(35392)},
			{Name: "GL_UNIFORM_BLOCK_NAME_LENGTH", Value: uint32(35393)},
			{Name: "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS", Value: uint32(35394)},
			{Name: "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", Value: uint32(35395)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", Value: uint32(35396)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER", Value: uint32(35397)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", Value: uint32(35398)},
			{Name: "GL_TEXTURE_SRGB_DECODE_EXT", Value: uint32(35400)},
			{Name: "GL_DECODE_EXT", Value: uint32(35401)},
			{Name: "GL_SKIP_DECODE_EXT", Value: uint32(35402)},
			{Name: "GL_PROGRAM_PIPELINE_OBJECT_EXT", Value: uint32(35407)},
			{Name: "GL_RGB_RAW_422_APPLE", Value: uint32(35409)},
			{Name: "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT", Value: uint32(35410)},
			{Name: "GL_SYNC_OBJECT_APPLE", Value: uint32(35411)},
			{Name: "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT", Value: uint32(35412)},
			{Name: "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT", Value: uint32(35413)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT", Value: uint32(35414)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT", Value: uint32(35415)},
			{Name: "GL_FRAGMENT_SHADER_ARB", Value: uint32(35632)},
			{Name: "GL_FRAGMENT_SHADER", Value: uint32(35632)},
			{Name: "GL_VERTEX_SHADER", Value: uint32(35633)},
			{Name: "GL_VERTEX_SHADER_ARB", Value: uint32(35633)},
			{Name: "GL_PROGRAM_OBJECT_EXT", Value: uint32(35648)},
			{Name: "GL_PROGRAM_OBJECT_ARB", Value: uint32(35648)},
			{Name: "GL_SHADER_OBJECT_ARB", Value: uint32(35656)},
			{Name: "GL_SHADER_OBJECT_EXT", Value: uint32(35656)},
			{Name: "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB", Value: uint32(35657)},
			{Name: "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS", Value: uint32(35657)},
			{Name: "GL_MAX_VERTEX_UNIFORM_COMPONENTS", Value: uint32(35658)},
			{Name: "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB", Value: uint32(35658)},
			{Name: "GL_MAX_VARYING_FLOATS_ARB", Value: uint32(35659)},
			{Name: "GL_MAX_VARYING_COMPONENTS_EXT", Value: uint32(35659)},
			{Name: "GL_MAX_VARYING_FLOATS", Value: uint32(35659)},
			{Name: "GL_MAX_VARYING_COMPONENTS", Value: uint32(35659)},
			{Name: "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB", Value: uint32(35660)},
			{Name: "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS", Value: uint32(35660)},
			{Name: "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS", Value: uint32(35661)},
			{Name: "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB", Value: uint32(35661)},
			{Name: "GL_OBJECT_TYPE_ARB", Value: uint32(35662)},
			{Name: "GL_OBJECT_SUBTYPE_ARB", Value: uint32(35663)},
			{Name: "GL_SHADER_TYPE", Value: uint32(35663)},
			{Name: "GL_FLOAT_VEC2_ARB", Value: uint32(35664)},
			{Name: "GL_FLOAT_VEC2", Value: uint32(35664)},
			{Name: "GL_FLOAT_VEC3_ARB", Value: uint32(35665)},
			{Name: "GL_FLOAT_VEC3", Value: uint32(35665)},
			{Name: "GL_FLOAT_VEC4_ARB", Value: uint32(35666)},
			{Name: "GL_FLOAT_VEC4", Value: uint32(35666)},
			{Name: "GL_INT_VEC2", Value: uint32(35667)},
			{Name: "GL_INT_VEC2_ARB", Value: uint32(35667)},
			{Name: "GL_INT_VEC3_ARB", Value: uint32(35668)},
			{Name: "GL_INT_VEC3", Value: uint32(35668)},
			{Name: "GL_INT_VEC4", Value: uint32(35669)},
			{Name: "GL_INT_VEC4_ARB", Value: uint32(35669)},
			{Name: "GL_BOOL_ARB", Value: uint32(35670)},
			{Name: "GL_BOOL", Value: uint32(35670)},
			{Name: "GL_BOOL_VEC2", Value: uint32(35671)},
			{Name: "GL_BOOL_VEC2_ARB", Value: uint32(35671)},
			{Name: "GL_BOOL_VEC3_ARB", Value: uint32(35672)},
			{Name: "GL_BOOL_VEC3", Value: uint32(35672)},
			{Name: "GL_BOOL_VEC4", Value: uint32(35673)},
			{Name: "GL_BOOL_VEC4_ARB", Value: uint32(35673)},
			{Name: "GL_FLOAT_MAT2_ARB", Value: uint32(35674)},
			{Name: "GL_FLOAT_MAT2", Value: uint32(35674)},
			{Name: "GL_FLOAT_MAT3_ARB", Value: uint32(35675)},
			{Name: "GL_FLOAT_MAT3", Value: uint32(35675)},
			{Name: "GL_FLOAT_MAT4", Value: uint32(35676)},
			{Name: "GL_FLOAT_MAT4_ARB", Value: uint32(35676)},
			{Name: "GL_SAMPLER_1D", Value: uint32(35677)},
			{Name: "GL_SAMPLER_1D_ARB", Value: uint32(35677)},
			{Name: "GL_SAMPLER_2D", Value: uint32(35678)},
			{Name: "GL_SAMPLER_2D_ARB", Value: uint32(35678)},
			{Name: "GL_SAMPLER_3D_ARB", Value: uint32(35679)},
			{Name: "GL_SAMPLER_3D", Value: uint32(35679)},
			{Name: "GL_SAMPLER_3D_OES", Value: uint32(35679)},
			{Name: "GL_SAMPLER_CUBE_ARB", Value: uint32(35680)},
			{Name: "GL_SAMPLER_CUBE", Value: uint32(35680)},
			{Name: "GL_SAMPLER_1D_SHADOW_ARB", Value: uint32(35681)},
			{Name: "GL_SAMPLER_1D_SHADOW", Value: uint32(35681)},
			{Name: "GL_SAMPLER_2D_SHADOW_EXT", Value: uint32(35682)},
			{Name: "GL_SAMPLER_2D_SHADOW_ARB", Value: uint32(35682)},
			{Name: "GL_SAMPLER_2D_SHADOW", Value: uint32(35682)},
			{Name: "GL_SAMPLER_2D_RECT_ARB", Value: uint32(35683)},
			{Name: "GL_SAMPLER_2D_RECT", Value: uint32(35683)},
			{Name: "GL_SAMPLER_2D_RECT_SHADOW", Value: uint32(35684)},
			{Name: "GL_SAMPLER_2D_RECT_SHADOW_ARB", Value: uint32(35684)},
			{Name: "GL_FLOAT_MAT2x3", Value: uint32(35685)},
			{Name: "GL_FLOAT_MAT2x3_NV", Value: uint32(35685)},
			{Name: "GL_FLOAT_MAT2x4_NV", Value: uint32(35686)},
			{Name: "GL_FLOAT_MAT2x4", Value: uint32(35686)},
			{Name: "GL_FLOAT_MAT3x2", Value: uint32(35687)},
			{Name: "GL_FLOAT_MAT3x2_NV", Value: uint32(35687)},
			{Name: "GL_FLOAT_MAT3x4", Value: uint32(35688)},
			{Name: "GL_FLOAT_MAT3x4_NV", Value: uint32(35688)},
			{Name: "GL_FLOAT_MAT4x2", Value: uint32(35689)},
			{Name: "GL_FLOAT_MAT4x2_NV", Value: uint32(35689)},
			{Name: "GL_FLOAT_MAT4x3", Value: uint32(35690)},
			{Name: "GL_FLOAT_MAT4x3_NV", Value: uint32(35690)},
			{Name: "GL_DELETE_STATUS", Value: uint32(35712)},
			{Name: "GL_OBJECT_DELETE_STATUS_ARB", Value: uint32(35712)},
			{Name: "GL_OBJECT_COMPILE_STATUS_ARB", Value: uint32(35713)},
			{Name: "GL_COMPILE_STATUS", Value: uint32(35713)},
			{Name: "GL_OBJECT_LINK_STATUS_ARB", Value: uint32(35714)},
			{Name: "GL_LINK_STATUS", Value: uint32(35714)},
			{Name: "GL_OBJECT_VALIDATE_STATUS_ARB", Value: uint32(35715)},
			{Name: "GL_VALIDATE_STATUS", Value: uint32(35715)},
			{Name: "GL_INFO_LOG_LENGTH", Value: uint32(35716)},
			{Name: "GL_OBJECT_INFO_LOG_LENGTH_ARB", Value: uint32(35716)},
			{Name: "GL_OBJECT_ATTACHED_OBJECTS_ARB", Value: uint32(35717)},
			{Name: "GL_ATTACHED_SHADERS", Value: uint32(35717)},
			{Name: "GL_ACTIVE_UNIFORMS", Value: uint32(35718)},
			{Name: "GL_OBJECT_ACTIVE_UNIFORMS_ARB", Value: uint32(35718)},
			{Name: "GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB", Value: uint32(35719)},
			{Name: "GL_ACTIVE_UNIFORM_MAX_LENGTH", Value: uint32(35719)},
			{Name: "GL_SHADER_SOURCE_LENGTH", Value: uint32(35720)},
			{Name: "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB", Value: uint32(35720)},
			{Name: "GL_ACTIVE_ATTRIBUTES", Value: uint32(35721)},
			{Name: "GL_OBJECT_ACTIVE_ATTRIBUTES_ARB", Value: uint32(35721)},
			{Name: "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH", Value: uint32(35722)},
			{Name: "GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB", Value: uint32(35722)},
			{Name: "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES", Value: uint32(35723)},
			{Name: "GL_FRAGMENT_SHADER_DERIVATIVE_HINT", Value: uint32(35723)},
			{Name: "GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB", Value: uint32(35723)},
			{Name: "GL_SHADING_LANGUAGE_VERSION", Value: uint32(35724)},
			{Name: "GL_SHADING_LANGUAGE_VERSION_ARB", Value: uint32(35724)},
			{Name: "GL_CURRENT_PROGRAM", Value: uint32(35725)},
			{Name: "GL_PALETTE4_RGB8_OES", Value: uint32(35728)},
			{Name: "GL_PALETTE4_RGBA8_OES", Value: uint32(35729)},
			{Name: "GL_PALETTE4_R5_G6_B5_OES", Value: uint32(35730)},
			{Name: "GL_PALETTE4_RGBA4_OES", Value: uint32(35731)},
			{Name: "GL_PALETTE4_RGB5_A1_OES", Value: uint32(35732)},
			{Name: "GL_PALETTE8_RGB8_OES", Value: uint32(35733)},
			{Name: "GL_PALETTE8_RGBA8_OES", Value: uint32(35734)},
			{Name: "GL_PALETTE8_R5_G6_B5_OES", Value: uint32(35735)},
			{Name: "GL_PALETTE8_RGBA4_OES", Value: uint32(35736)},
			{Name: "GL_PALETTE8_RGB5_A1_OES", Value: uint32(35737)},
			{Name: "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES", Value: uint32(35738)},
			{Name: "GL_IMPLEMENTATION_COLOR_READ_TYPE", Value: uint32(35738)},
			{Name: "GL_IMPLEMENTATION_COLOR_READ_FORMAT", Value: uint32(35739)},
			{Name: "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES", Value: uint32(35739)},
			{Name: "GL_POINT_SIZE_ARRAY_OES", Value: uint32(35740)},
			{Name: "GL_TEXTURE_CROP_RECT_OES", Value: uint32(35741)},
			{Name: "GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES", Value: uint32(35742)},
			{Name: "GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES", Value: uint32(35743)},
			{Name: "GL_FRAGMENT_PROGRAM_POSITION_MESA", Value: uint32(35760)},
			{Name: "GL_FRAGMENT_PROGRAM_CALLBACK_MESA", Value: uint32(35761)},
			{Name: "GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA", Value: uint32(35762)},
			{Name: "GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA", Value: uint32(35763)},
			{Name: "GL_VERTEX_PROGRAM_POSITION_MESA", Value: uint32(35764)},
			{Name: "GL_VERTEX_PROGRAM_CALLBACK_MESA", Value: uint32(35765)},
			{Name: "GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA", Value: uint32(35766)},
			{Name: "GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA", Value: uint32(35767)},
			{Name: "GL_COUNTER_TYPE_AMD", Value: uint32(35776)},
			{Name: "GL_COUNTER_RANGE_AMD", Value: uint32(35777)},
			{Name: "GL_UNSIGNED_INT64_AMD", Value: uint32(35778)},
			{Name: "GL_PERCENTAGE_AMD", Value: uint32(35779)},
			{Name: "GL_PERFMON_RESULT_AVAILABLE_AMD", Value: uint32(35780)},
			{Name: "GL_PERFMON_RESULT_SIZE_AMD", Value: uint32(35781)},
			{Name: "GL_PERFMON_RESULT_AMD", Value: uint32(35782)},
			{Name: "GL_TEXTURE_WIDTH_QCOM", Value: uint32(35794)},
			{Name: "GL_TEXTURE_HEIGHT_QCOM", Value: uint32(35795)},
			{Name: "GL_TEXTURE_DEPTH_QCOM", Value: uint32(35796)},
			{Name: "GL_TEXTURE_INTERNAL_FORMAT_QCOM", Value: uint32(35797)},
			{Name: "GL_TEXTURE_FORMAT_QCOM", Value: uint32(35798)},
			{Name: "GL_TEXTURE_TYPE_QCOM", Value: uint32(35799)},
			{Name: "GL_TEXTURE_IMAGE_VALID_QCOM", Value: uint32(35800)},
			{Name: "GL_TEXTURE_NUM_LEVELS_QCOM", Value: uint32(35801)},
			{Name: "GL_TEXTURE_TARGET_QCOM", Value: uint32(35802)},
			{Name: "GL_TEXTURE_OBJECT_VALID_QCOM", Value: uint32(35803)},
			{Name: "GL_STATE_RESTORE", Value: uint32(35804)},
			{Name: "GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT", Value: uint32(35815)},
			{Name: "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG", Value: uint32(35840)},
			{Name: "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG", Value: uint32(35841)},
			{Name: "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG", Value: uint32(35842)},
			{Name: "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG", Value: uint32(35843)},
			{Name: "GL_MODULATE_COLOR_IMG", Value: uint32(35844)},
			{Name: "GL_RECIP_ADD_SIGNED_ALPHA_IMG", Value: uint32(35845)},
			{Name: "GL_TEXTURE_ALPHA_MODULATE_IMG", Value: uint32(35846)},
			{Name: "GL_FACTOR_ALPHA_MODULATE_IMG", Value: uint32(35847)},
			{Name: "GL_FRAGMENT_ALPHA_MODULATE_IMG", Value: uint32(35848)},
			{Name: "GL_ADD_BLEND_IMG", Value: uint32(35849)},
			{Name: "GL_SGX_BINARY_IMG", Value: uint32(35850)},
			{Name: "GL_TEXTURE_RED_TYPE", Value: uint32(35856)},
			{Name: "GL_TEXTURE_RED_TYPE_ARB", Value: uint32(35856)},
			{Name: "GL_TEXTURE_GREEN_TYPE_ARB", Value: uint32(35857)},
			{Name: "GL_TEXTURE_GREEN_TYPE", Value: uint32(35857)},
			{Name: "GL_TEXTURE_BLUE_TYPE_ARB", Value: uint32(35858)},
			{Name: "GL_TEXTURE_BLUE_TYPE", Value: uint32(35858)},
			{Name: "GL_TEXTURE_ALPHA_TYPE_ARB", Value: uint32(35859)},
			{Name: "GL_TEXTURE_ALPHA_TYPE", Value: uint32(35859)},
			{Name: "GL_TEXTURE_LUMINANCE_TYPE_ARB", Value: uint32(35860)},
			{Name: "GL_TEXTURE_LUMINANCE_TYPE", Value: uint32(35860)},
			{Name: "GL_TEXTURE_INTENSITY_TYPE_ARB", Value: uint32(35861)},
			{Name: "GL_TEXTURE_INTENSITY_TYPE", Value: uint32(35861)},
			{Name: "GL_TEXTURE_DEPTH_TYPE_ARB", Value: uint32(35862)},
			{Name: "GL_TEXTURE_DEPTH_TYPE", Value: uint32(35862)},
			{Name: "GL_UNSIGNED_NORMALIZED_EXT", Value: uint32(35863)},
			{Name: "GL_UNSIGNED_NORMALIZED_ARB", Value: uint32(35863)},
			{Name: "GL_UNSIGNED_NORMALIZED", Value: uint32(35863)},
			{Name: "GL_TEXTURE_1D_ARRAY_EXT", Value: uint32(35864)},
			{Name: "GL_TEXTURE_1D_ARRAY", Value: uint32(35864)},
			{Name: "GL_PROXY_TEXTURE_1D_ARRAY_EXT", Value: uint32(35865)},
			{Name: "GL_PROXY_TEXTURE_1D_ARRAY", Value: uint32(35865)},
			{Name: "GL_TEXTURE_2D_ARRAY", Value: uint32(35866)},
			{Name: "GL_TEXTURE_2D_ARRAY_EXT", Value: uint32(35866)},
			{Name: "GL_PROXY_TEXTURE_2D_ARRAY_EXT", Value: uint32(35867)},
			{Name: "GL_PROXY_TEXTURE_2D_ARRAY", Value: uint32(35867)},
			{Name: "GL_TEXTURE_BINDING_1D_ARRAY", Value: uint32(35868)},
			{Name: "GL_TEXTURE_BINDING_1D_ARRAY_EXT", Value: uint32(35868)},
			{Name: "GL_TEXTURE_BINDING_2D_ARRAY", Value: uint32(35869)},
			{Name: "GL_TEXTURE_BINDING_2D_ARRAY_EXT", Value: uint32(35869)},
			{Name: "GL_GEOMETRY_PROGRAM_NV", Value: uint32(35878)},
			{Name: "GL_MAX_PROGRAM_OUTPUT_VERTICES_NV", Value: uint32(35879)},
			{Name: "GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV", Value: uint32(35880)},
			{Name: "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS", Value: uint32(35881)},
			{Name: "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB", Value: uint32(35881)},
			{Name: "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES", Value: uint32(35881)},
			{Name: "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT", Value: uint32(35881)},
			{Name: "GL_TEXTURE_BUFFER_BINDING_OES", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER_OES", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER_BINDING", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER_ARB", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER_EXT", Value: uint32(35882)},
			{Name: "GL_TEXTURE_BUFFER_BINDING_EXT", Value: uint32(35882)},
			{Name: "GL_MAX_TEXTURE_BUFFER_SIZE_ARB", Value: uint32(35883)},
			{Name: "GL_MAX_TEXTURE_BUFFER_SIZE_EXT", Value: uint32(35883)},
			{Name: "GL_MAX_TEXTURE_BUFFER_SIZE_OES", Value: uint32(35883)},
			{Name: "GL_MAX_TEXTURE_BUFFER_SIZE", Value: uint32(35883)},
			{Name: "GL_TEXTURE_BINDING_BUFFER_OES", Value: uint32(35884)},
			{Name: "GL_TEXTURE_BINDING_BUFFER", Value: uint32(35884)},
			{Name: "GL_TEXTURE_BINDING_BUFFER_ARB", Value: uint32(35884)},
			{Name: "GL_TEXTURE_BINDING_BUFFER_EXT", Value: uint32(35884)},
			{Name: "GL_TEXTURE_BUFFER_DATA_STORE_BINDING", Value: uint32(35885)},
			{Name: "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT", Value: uint32(35885)},
			{Name: "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES", Value: uint32(35885)},
			{Name: "GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB", Value: uint32(35885)},
			{Name: "GL_TEXTURE_BUFFER_FORMAT_EXT", Value: uint32(35886)},
			{Name: "GL_TEXTURE_BUFFER_FORMAT_ARB", Value: uint32(35886)},
			{Name: "GL_ANY_SAMPLES_PASSED_EXT", Value: uint32(35887)},
			{Name: "GL_ANY_SAMPLES_PASSED", Value: uint32(35887)},
			{Name: "GL_SAMPLE_SHADING_OES", Value: uint32(35894)},
			{Name: "GL_SAMPLE_SHADING_ARB", Value: uint32(35894)},
			{Name: "GL_SAMPLE_SHADING", Value: uint32(35894)},
			{Name: "GL_MIN_SAMPLE_SHADING_VALUE", Value: uint32(35895)},
			{Name: "GL_MIN_SAMPLE_SHADING_VALUE_ARB", Value: uint32(35895)},
			{Name: "GL_MIN_SAMPLE_SHADING_VALUE_OES", Value: uint32(35895)},
			{Name: "GL_R11F_G11F_B10F_APPLE", Value: uint32(35898)},
			{Name: "GL_R11F_G11F_B10F", Value: uint32(35898)},
			{Name: "GL_R11F_G11F_B10F_EXT", Value: uint32(35898)},
			{Name: "GL_UNSIGNED_INT_10F_11F_11F_REV_EXT", Value: uint32(35899)},
			{Name: "GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE", Value: uint32(35899)},
			{Name: "GL_UNSIGNED_INT_10F_11F_11F_REV", Value: uint32(35899)},
			{Name: "GL_RGBA_SIGNED_COMPONENTS_EXT", Value: uint32(35900)},
			{Name: "GL_RGB9_E5_APPLE", Value: uint32(35901)},
			{Name: "GL_RGB9_E5", Value: uint32(35901)},
			{Name: "GL_RGB9_E5_EXT", Value: uint32(35901)},
			{Name: "GL_UNSIGNED_INT_5_9_9_9_REV_EXT", Value: uint32(35902)},
			{Name: "GL_UNSIGNED_INT_5_9_9_9_REV", Value: uint32(35902)},
			{Name: "GL_UNSIGNED_INT_5_9_9_9_REV_APPLE", Value: uint32(35902)},
			{Name: "GL_TEXTURE_SHARED_SIZE", Value: uint32(35903)},
			{Name: "GL_TEXTURE_SHARED_SIZE_EXT", Value: uint32(35903)},
			{Name: "GL_SRGB_EXT", Value: uint32(35904)},
			{Name: "GL_SRGB", Value: uint32(35904)},
			{Name: "GL_SRGB8_NV", Value: uint32(35905)},
			{Name: "GL_SRGB8", Value: uint32(35905)},
			{Name: "GL_SRGB8_EXT", Value: uint32(35905)},
			{Name: "GL_SRGB_ALPHA_EXT", Value: uint32(35906)},
			{Name: "GL_SRGB_ALPHA", Value: uint32(35906)},
			{Name: "GL_SRGB8_ALPHA8_EXT", Value: uint32(35907)},
			{Name: "GL_SRGB8_ALPHA8", Value: uint32(35907)},
			{Name: "GL_SLUMINANCE_ALPHA", Value: uint32(35908)},
			{Name: "GL_SLUMINANCE_ALPHA_NV", Value: uint32(35908)},
			{Name: "GL_SLUMINANCE_ALPHA_EXT", Value: uint32(35908)},
			{Name: "GL_SLUMINANCE8_ALPHA8", Value: uint32(35909)},
			{Name: "GL_SLUMINANCE8_ALPHA8_EXT", Value: uint32(35909)},
			{Name: "GL_SLUMINANCE8_ALPHA8_NV", Value: uint32(35909)},
			{Name: "GL_SLUMINANCE_NV", Value: uint32(35910)},
			{Name: "GL_SLUMINANCE_EXT", Value: uint32(35910)},
			{Name: "GL_SLUMINANCE", Value: uint32(35910)},
			{Name: "GL_SLUMINANCE8_EXT", Value: uint32(35911)},
			{Name: "GL_SLUMINANCE8_NV", Value: uint32(35911)},
			{Name: "GL_SLUMINANCE8", Value: uint32(35911)},
			{Name: "GL_COMPRESSED_SRGB_EXT", Value: uint32(35912)},
			{Name: "GL_COMPRESSED_SRGB", Value: uint32(35912)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_EXT", Value: uint32(35913)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA", Value: uint32(35913)},
			{Name: "GL_COMPRESSED_SLUMINANCE", Value: uint32(35914)},
			{Name: "GL_COMPRESSED_SLUMINANCE_EXT", Value: uint32(35914)},
			{Name: "GL_COMPRESSED_SLUMINANCE_ALPHA_EXT", Value: uint32(35915)},
			{Name: "GL_COMPRESSED_SLUMINANCE_ALPHA", Value: uint32(35915)},
			{Name: "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT", Value: uint32(35916)},
			{Name: "GL_COMPRESSED_SRGB_S3TC_DXT1_NV", Value: uint32(35916)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV", Value: uint32(35917)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT", Value: uint32(35917)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT", Value: uint32(35918)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV", Value: uint32(35918)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV", Value: uint32(35919)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT", Value: uint32(35919)},
			{Name: "GL_COMPRESSED_LUMINANCE_LATC1_EXT", Value: uint32(35952)},
			{Name: "GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT", Value: uint32(35953)},
			{Name: "GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT", Value: uint32(35954)},
			{Name: "GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT", Value: uint32(35955)},
			{Name: "GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(35956)},
			{Name: "GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(35957)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH", Value: uint32(35958)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT", Value: uint32(35958)},
			{Name: "GL_BACK_PRIMARY_COLOR_NV", Value: uint32(35959)},
			{Name: "GL_BACK_SECONDARY_COLOR_NV", Value: uint32(35960)},
			{Name: "GL_TEXTURE_COORD_NV", Value: uint32(35961)},
			{Name: "GL_CLIP_DISTANCE_NV", Value: uint32(35962)},
			{Name: "GL_VERTEX_ID_NV", Value: uint32(35963)},
			{Name: "GL_PRIMITIVE_ID_NV", Value: uint32(35964)},
			{Name: "GL_GENERIC_ATTRIB_NV", Value: uint32(35965)},
			{Name: "GL_TRANSFORM_FEEDBACK_ATTRIBS_NV", Value: uint32(35966)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT", Value: uint32(35967)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV", Value: uint32(35967)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_MODE", Value: uint32(35967)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT", Value: uint32(35968)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS", Value: uint32(35968)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV", Value: uint32(35968)},
			{Name: "GL_ACTIVE_VARYINGS_NV", Value: uint32(35969)},
			{Name: "GL_ACTIVE_VARYING_MAX_LENGTH_NV", Value: uint32(35970)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT", Value: uint32(35971)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYINGS", Value: uint32(35971)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYINGS_NV", Value: uint32(35971)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT", Value: uint32(35972)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_START", Value: uint32(35972)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_START_NV", Value: uint32(35972)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE", Value: uint32(35973)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT", Value: uint32(35973)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV", Value: uint32(35973)},
			{Name: "GL_TRANSFORM_FEEDBACK_RECORD_NV", Value: uint32(35974)},
			{Name: "GL_PRIMITIVES_GENERATED", Value: uint32(35975)},
			{Name: "GL_PRIMITIVES_GENERATED_EXT", Value: uint32(35975)},
			{Name: "GL_PRIMITIVES_GENERATED_NV", Value: uint32(35975)},
			{Name: "GL_PRIMITIVES_GENERATED_OES", Value: uint32(35975)},
			{Name: "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT", Value: uint32(35976)},
			{Name: "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", Value: uint32(35976)},
			{Name: "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV", Value: uint32(35976)},
			{Name: "GL_RASTERIZER_DISCARD_NV", Value: uint32(35977)},
			{Name: "GL_RASTERIZER_DISCARD", Value: uint32(35977)},
			{Name: "GL_RASTERIZER_DISCARD_EXT", Value: uint32(35977)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT", Value: uint32(35978)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", Value: uint32(35978)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV", Value: uint32(35978)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT", Value: uint32(35979)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", Value: uint32(35979)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV", Value: uint32(35979)},
			{Name: "GL_INTERLEAVED_ATTRIBS_EXT", Value: uint32(35980)},
			{Name: "GL_INTERLEAVED_ATTRIBS", Value: uint32(35980)},
			{Name: "GL_INTERLEAVED_ATTRIBS_NV", Value: uint32(35980)},
			{Name: "GL_SEPARATE_ATTRIBS_NV", Value: uint32(35981)},
			{Name: "GL_SEPARATE_ATTRIBS", Value: uint32(35981)},
			{Name: "GL_SEPARATE_ATTRIBS_EXT", Value: uint32(35981)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER", Value: uint32(35982)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_NV", Value: uint32(35982)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_EXT", Value: uint32(35982)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING", Value: uint32(35983)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV", Value: uint32(35983)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT", Value: uint32(35983)},
			{Name: "GL_ATC_RGB_AMD", Value: uint32(35986)},
			{Name: "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD", Value: uint32(35987)},
			{Name: "GL_POINT_SPRITE_COORD_ORIGIN", Value: uint32(36000)},
			{Name: "GL_LOWER_LEFT", Value: uint32(36001)},
			{Name: "GL_UPPER_LEFT", Value: uint32(36002)},
			{Name: "GL_STENCIL_BACK_REF", Value: uint32(36003)},
			{Name: "GL_STENCIL_BACK_VALUE_MASK", Value: uint32(36004)},
			{Name: "GL_STENCIL_BACK_WRITEMASK", Value: uint32(36005)},
			{Name: "GL_FRAMEBUFFER_BINDING", Value: uint32(36006)},
			{Name: "GL_FRAMEBUFFER_BINDING_EXT", Value: uint32(36006)},
			{Name: "GL_FRAMEBUFFER_BINDING_ANGLE", Value: uint32(36006)},
			{Name: "GL_DRAW_FRAMEBUFFER_BINDING_APPLE", Value: uint32(36006)},
			{Name: "GL_DRAW_FRAMEBUFFER_BINDING_ANGLE", Value: uint32(36006)},
			{Name: "GL_DRAW_FRAMEBUFFER_BINDING", Value: uint32(36006)},
			{Name: "GL_DRAW_FRAMEBUFFER_BINDING_EXT", Value: uint32(36006)},
			{Name: "GL_DRAW_FRAMEBUFFER_BINDING_NV", Value: uint32(36006)},
			{Name: "GL_FRAMEBUFFER_BINDING_OES", Value: uint32(36006)},
			{Name: "GL_RENDERBUFFER_BINDING", Value: uint32(36007)},
			{Name: "GL_RENDERBUFFER_BINDING_ANGLE", Value: uint32(36007)},
			{Name: "GL_RENDERBUFFER_BINDING_EXT", Value: uint32(36007)},
			{Name: "GL_RENDERBUFFER_BINDING_OES", Value: uint32(36007)},
			{Name: "GL_READ_FRAMEBUFFER", Value: uint32(36008)},
			{Name: "GL_READ_FRAMEBUFFER_ANGLE", Value: uint32(36008)},
			{Name: "GL_READ_FRAMEBUFFER_NV", Value: uint32(36008)},
			{Name: "GL_READ_FRAMEBUFFER_APPLE", Value: uint32(36008)},
			{Name: "GL_READ_FRAMEBUFFER_EXT", Value: uint32(36008)},
			{Name: "GL_DRAW_FRAMEBUFFER", Value: uint32(36009)},
			{Name: "GL_DRAW_FRAMEBUFFER_APPLE", Value: uint32(36009)},
			{Name: "GL_DRAW_FRAMEBUFFER_ANGLE", Value: uint32(36009)},
			{Name: "GL_DRAW_FRAMEBUFFER_EXT", Value: uint32(36009)},
			{Name: "GL_DRAW_FRAMEBUFFER_NV", Value: uint32(36009)},
			{Name: "GL_READ_FRAMEBUFFER_BINDING", Value: uint32(36010)},
			{Name: "GL_READ_FRAMEBUFFER_BINDING_NV", Value: uint32(36010)},
			{Name: "GL_READ_FRAMEBUFFER_BINDING_EXT", Value: uint32(36010)},
			{Name: "GL_READ_FRAMEBUFFER_BINDING_ANGLE", Value: uint32(36010)},
			{Name: "GL_READ_FRAMEBUFFER_BINDING_APPLE", Value: uint32(36010)},
			{Name: "GL_RENDERBUFFER_COVERAGE_SAMPLES_NV", Value: uint32(36011)},
			{Name: "GL_RENDERBUFFER_SAMPLES_APPLE", Value: uint32(36011)},
			{Name: "GL_RENDERBUFFER_SAMPLES_EXT", Value: uint32(36011)},
			{Name: "GL_RENDERBUFFER_SAMPLES", Value: uint32(36011)},
			{Name: "GL_RENDERBUFFER_SAMPLES_NV", Value: uint32(36011)},
			{Name: "GL_RENDERBUFFER_SAMPLES_ANGLE", Value: uint32(36011)},
			{Name: "GL_DEPTH_COMPONENT32F", Value: uint32(36012)},
			{Name: "GL_DEPTH32F_STENCIL8", Value: uint32(36013)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT", Value: uint32(36048)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES", Value: uint32(36048)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", Value: uint32(36048)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", Value: uint32(36049)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT", Value: uint32(36049)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES", Value: uint32(36049)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT", Value: uint32(36050)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES", Value: uint32(36050)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", Value: uint32(36050)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", Value: uint32(36051)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT", Value: uint32(36051)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES", Value: uint32(36051)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT", Value: uint32(36052)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", Value: uint32(36052)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT", Value: uint32(36052)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES", Value: uint32(36052)},
			{Name: "GL_FRAMEBUFFER_COMPLETE", Value: uint32(36053)},
			{Name: "GL_FRAMEBUFFER_COMPLETE_OES", Value: uint32(36053)},
			{Name: "GL_FRAMEBUFFER_COMPLETE_EXT", Value: uint32(36053)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES", Value: uint32(36054)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT", Value: uint32(36054)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT", Value: uint32(36054)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT", Value: uint32(36055)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES", Value: uint32(36055)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", Value: uint32(36055)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT", Value: uint32(36057)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES", Value: uint32(36057)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS", Value: uint32(36057)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES", Value: uint32(36058)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT", Value: uint32(36058)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER", Value: uint32(36059)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT", Value: uint32(36059)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES", Value: uint32(36059)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER", Value: uint32(36060)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES", Value: uint32(36060)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT", Value: uint32(36060)},
			{Name: "GL_FRAMEBUFFER_UNSUPPORTED_EXT", Value: uint32(36061)},
			{Name: "GL_FRAMEBUFFER_UNSUPPORTED", Value: uint32(36061)},
			{Name: "GL_FRAMEBUFFER_UNSUPPORTED_OES", Value: uint32(36061)},
			{Name: "GL_MAX_COLOR_ATTACHMENTS", Value: uint32(36063)},
			{Name: "GL_MAX_COLOR_ATTACHMENTS_NV", Value: uint32(36063)},
			{Name: "GL_MAX_COLOR_ATTACHMENTS_EXT", Value: uint32(36063)},
			{Name: "GL_COLOR_ATTACHMENT0_EXT", Value: uint32(36064)},
			{Name: "GL_COLOR_ATTACHMENT0_NV", Value: uint32(36064)},
			{Name: "GL_COLOR_ATTACHMENT0", Value: uint32(36064)},
			{Name: "GL_COLOR_ATTACHMENT0_OES", Value: uint32(36064)},
			{Name: "GL_COLOR_ATTACHMENT1_EXT", Value: uint32(36065)},
			{Name: "GL_COLOR_ATTACHMENT1", Value: uint32(36065)},
			{Name: "GL_COLOR_ATTACHMENT1_NV", Value: uint32(36065)},
			{Name: "GL_COLOR_ATTACHMENT2", Value: uint32(36066)},
			{Name: "GL_COLOR_ATTACHMENT2_NV", Value: uint32(36066)},
			{Name: "GL_COLOR_ATTACHMENT2_EXT", Value: uint32(36066)},
			{Name: "GL_COLOR_ATTACHMENT3", Value: uint32(36067)},
			{Name: "GL_COLOR_ATTACHMENT3_EXT", Value: uint32(36067)},
			{Name: "GL_COLOR_ATTACHMENT3_NV", Value: uint32(36067)},
			{Name: "GL_COLOR_ATTACHMENT4_EXT", Value: uint32(36068)},
			{Name: "GL_COLOR_ATTACHMENT4", Value: uint32(36068)},
			{Name: "GL_COLOR_ATTACHMENT4_NV", Value: uint32(36068)},
			{Name: "GL_COLOR_ATTACHMENT5_NV", Value: uint32(36069)},
			{Name: "GL_COLOR_ATTACHMENT5_EXT", Value: uint32(36069)},
			{Name: "GL_COLOR_ATTACHMENT5", Value: uint32(36069)},
			{Name: "GL_COLOR_ATTACHMENT6", Value: uint32(36070)},
			{Name: "GL_COLOR_ATTACHMENT6_NV", Value: uint32(36070)},
			{Name: "GL_COLOR_ATTACHMENT6_EXT", Value: uint32(36070)},
			{Name: "GL_COLOR_ATTACHMENT7", Value: uint32(36071)},
			{Name: "GL_COLOR_ATTACHMENT7_NV", Value: uint32(36071)},
			{Name: "GL_COLOR_ATTACHMENT7_EXT", Value: uint32(36071)},
			{Name: "GL_COLOR_ATTACHMENT8_NV", Value: uint32(36072)},
			{Name: "GL_COLOR_ATTACHMENT8_EXT", Value: uint32(36072)},
			{Name: "GL_COLOR_ATTACHMENT8", Value: uint32(36072)},
			{Name: "GL_COLOR_ATTACHMENT9_EXT", Value: uint32(36073)},
			{Name: "GL_COLOR_ATTACHMENT9_NV", Value: uint32(36073)},
			{Name: "GL_COLOR_ATTACHMENT9", Value: uint32(36073)},
			{Name: "GL_COLOR_ATTACHMENT10_NV", Value: uint32(36074)},
			{Name: "GL_COLOR_ATTACHMENT10", Value: uint32(36074)},
			{Name: "GL_COLOR_ATTACHMENT10_EXT", Value: uint32(36074)},
			{Name: "GL_COLOR_ATTACHMENT11", Value: uint32(36075)},
			{Name: "GL_COLOR_ATTACHMENT11_NV", Value: uint32(36075)},
			{Name: "GL_COLOR_ATTACHMENT11_EXT", Value: uint32(36075)},
			{Name: "GL_COLOR_ATTACHMENT12_NV", Value: uint32(36076)},
			{Name: "GL_COLOR_ATTACHMENT12", Value: uint32(36076)},
			{Name: "GL_COLOR_ATTACHMENT12_EXT", Value: uint32(36076)},
			{Name: "GL_COLOR_ATTACHMENT13_EXT", Value: uint32(36077)},
			{Name: "GL_COLOR_ATTACHMENT13_NV", Value: uint32(36077)},
			{Name: "GL_COLOR_ATTACHMENT13", Value: uint32(36077)},
			{Name: "GL_COLOR_ATTACHMENT14_NV", Value: uint32(36078)},
			{Name: "GL_COLOR_ATTACHMENT14_EXT", Value: uint32(36078)},
			{Name: "GL_COLOR_ATTACHMENT14", Value: uint32(36078)},
			{Name: "GL_COLOR_ATTACHMENT15", Value: uint32(36079)},
			{Name: "GL_COLOR_ATTACHMENT15_EXT", Value: uint32(36079)},
			{Name: "GL_COLOR_ATTACHMENT15_NV", Value: uint32(36079)},
			{Name: "GL_COLOR_ATTACHMENT16", Value: uint32(36080)},
			{Name: "GL_COLOR_ATTACHMENT17", Value: uint32(36081)},
			{Name: "GL_COLOR_ATTACHMENT18", Value: uint32(36082)},
			{Name: "GL_COLOR_ATTACHMENT19", Value: uint32(36083)},
			{Name: "GL_COLOR_ATTACHMENT20", Value: uint32(36084)},
			{Name: "GL_COLOR_ATTACHMENT21", Value: uint32(36085)},
			{Name: "GL_COLOR_ATTACHMENT22", Value: uint32(36086)},
			{Name: "GL_COLOR_ATTACHMENT23", Value: uint32(36087)},
			{Name: "GL_COLOR_ATTACHMENT24", Value: uint32(36088)},
			{Name: "GL_COLOR_ATTACHMENT25", Value: uint32(36089)},
			{Name: "GL_COLOR_ATTACHMENT26", Value: uint32(36090)},
			{Name: "GL_COLOR_ATTACHMENT27", Value: uint32(36091)},
			{Name: "GL_COLOR_ATTACHMENT28", Value: uint32(36092)},
			{Name: "GL_COLOR_ATTACHMENT29", Value: uint32(36093)},
			{Name: "GL_COLOR_ATTACHMENT30", Value: uint32(36094)},
			{Name: "GL_COLOR_ATTACHMENT31", Value: uint32(36095)},
			{Name: "GL_DEPTH_ATTACHMENT", Value: uint32(36096)},
			{Name: "GL_DEPTH_ATTACHMENT_EXT", Value: uint32(36096)},
			{Name: "GL_DEPTH_ATTACHMENT_OES", Value: uint32(36096)},
			{Name: "GL_STENCIL_ATTACHMENT_OES", Value: uint32(36128)},
			{Name: "GL_STENCIL_ATTACHMENT", Value: uint32(36128)},
			{Name: "GL_STENCIL_ATTACHMENT_EXT", Value: uint32(36128)},
			{Name: "GL_FRAMEBUFFER_EXT", Value: uint32(36160)},
			{Name: "GL_FRAMEBUFFER_OES", Value: uint32(36160)},
			{Name: "GL_FRAMEBUFFER", Value: uint32(36160)},
			{Name: "GL_RENDERBUFFER_OES", Value: uint32(36161)},
			{Name: "GL_RENDERBUFFER_EXT", Value: uint32(36161)},
			{Name: "GL_RENDERBUFFER", Value: uint32(36161)},
			{Name: "GL_RENDERBUFFER_WIDTH", Value: uint32(36162)},
			{Name: "GL_RENDERBUFFER_WIDTH_OES", Value: uint32(36162)},
			{Name: "GL_RENDERBUFFER_WIDTH_EXT", Value: uint32(36162)},
			{Name: "GL_RENDERBUFFER_HEIGHT_OES", Value: uint32(36163)},
			{Name: "GL_RENDERBUFFER_HEIGHT", Value: uint32(36163)},
			{Name: "GL_RENDERBUFFER_HEIGHT_EXT", Value: uint32(36163)},
			{Name: "GL_RENDERBUFFER_INTERNAL_FORMAT", Value: uint32(36164)},
			{Name: "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT", Value: uint32(36164)},
			{Name: "GL_RENDERBUFFER_INTERNAL_FORMAT_OES", Value: uint32(36164)},
			{Name: "GL_STENCIL_INDEX1_OES", Value: uint32(36166)},
			{Name: "GL_STENCIL_INDEX1_EXT", Value: uint32(36166)},
			{Name: "GL_STENCIL_INDEX1", Value: uint32(36166)},
			{Name: "GL_STENCIL_INDEX4_EXT", Value: uint32(36167)},
			{Name: "GL_STENCIL_INDEX4", Value: uint32(36167)},
			{Name: "GL_STENCIL_INDEX4_OES", Value: uint32(36167)},
			{Name: "GL_STENCIL_INDEX8_EXT", Value: uint32(36168)},
			{Name: "GL_STENCIL_INDEX8", Value: uint32(36168)},
			{Name: "GL_STENCIL_INDEX8_OES", Value: uint32(36168)},
			{Name: "GL_STENCIL_INDEX16", Value: uint32(36169)},
			{Name: "GL_STENCIL_INDEX16_EXT", Value: uint32(36169)},
			{Name: "GL_RENDERBUFFER_RED_SIZE_EXT", Value: uint32(36176)},
			{Name: "GL_RENDERBUFFER_RED_SIZE", Value: uint32(36176)},
			{Name: "GL_RENDERBUFFER_RED_SIZE_OES", Value: uint32(36176)},
			{Name: "GL_RENDERBUFFER_GREEN_SIZE_EXT", Value: uint32(36177)},
			{Name: "GL_RENDERBUFFER_GREEN_SIZE", Value: uint32(36177)},
			{Name: "GL_RENDERBUFFER_GREEN_SIZE_OES", Value: uint32(36177)},
			{Name: "GL_RENDERBUFFER_BLUE_SIZE_OES", Value: uint32(36178)},
			{Name: "GL_RENDERBUFFER_BLUE_SIZE", Value: uint32(36178)},
			{Name: "GL_RENDERBUFFER_BLUE_SIZE_EXT", Value: uint32(36178)},
			{Name: "GL_RENDERBUFFER_ALPHA_SIZE", Value: uint32(36179)},
			{Name: "GL_RENDERBUFFER_ALPHA_SIZE_OES", Value: uint32(36179)},
			{Name: "GL_RENDERBUFFER_ALPHA_SIZE_EXT", Value: uint32(36179)},
			{Name: "GL_RENDERBUFFER_DEPTH_SIZE_OES", Value: uint32(36180)},
			{Name: "GL_RENDERBUFFER_DEPTH_SIZE_EXT", Value: uint32(36180)},
			{Name: "GL_RENDERBUFFER_DEPTH_SIZE", Value: uint32(36180)},
			{Name: "GL_RENDERBUFFER_STENCIL_SIZE", Value: uint32(36181)},
			{Name: "GL_RENDERBUFFER_STENCIL_SIZE_OES", Value: uint32(36181)},
			{Name: "GL_RENDERBUFFER_STENCIL_SIZE_EXT", Value: uint32(36181)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE", Value: uint32(36182)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT", Value: uint32(36182)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", Value: uint32(36182)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV", Value: uint32(36182)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE", Value: uint32(36182)},
			{Name: "GL_MAX_SAMPLES_ANGLE", Value: uint32(36183)},
			{Name: "GL_MAX_SAMPLES_APPLE", Value: uint32(36183)},
			{Name: "GL_MAX_SAMPLES_EXT", Value: uint32(36183)},
			{Name: "GL_MAX_SAMPLES_NV", Value: uint32(36183)},
			{Name: "GL_MAX_SAMPLES", Value: uint32(36183)},
			{Name: "GL_TEXTURE_GEN_STR_OES", Value: uint32(36192)},
			{Name: "GL_HALF_FLOAT_OES", Value: uint32(36193)},
			{Name: "GL_RGB565", Value: uint32(36194)},
			{Name: "GL_RGB565_OES", Value: uint32(36194)},
			{Name: "GL_ETC1_RGB8_OES", Value: uint32(36196)},
			{Name: "GL_TEXTURE_EXTERNAL_OES", Value: uint32(36197)},
			{Name: "GL_SAMPLER_EXTERNAL_OES", Value: uint32(36198)},
			{Name: "GL_TEXTURE_BINDING_EXTERNAL_OES", Value: uint32(36199)},
			{Name: "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES", Value: uint32(36200)},
			{Name: "GL_PRIMITIVE_RESTART_FIXED_INDEX", Value: uint32(36201)},
			{Name: "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT", Value: uint32(36202)},
			{Name: "GL_ANY_SAMPLES_PASSED_CONSERVATIVE", Value: uint32(36202)},
			{Name: "GL_MAX_ELEMENT_INDEX", Value: uint32(36203)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT", Value: uint32(36204)},
			{Name: "GL_RGBA32UI_EXT", Value: uint32(36208)},
			{Name: "GL_RGBA32UI", Value: uint32(36208)},
			{Name: "GL_RGB32UI_EXT", Value: uint32(36209)},
			{Name: "GL_RGB32UI", Value: uint32(36209)},
			{Name: "GL_ALPHA32UI_EXT", Value: uint32(36210)},
			{Name: "GL_INTENSITY32UI_EXT", Value: uint32(36211)},
			{Name: "GL_LUMINANCE32UI_EXT", Value: uint32(36212)},
			{Name: "GL_LUMINANCE_ALPHA32UI_EXT", Value: uint32(36213)},
			{Name: "GL_RGBA16UI_EXT", Value: uint32(36214)},
			{Name: "GL_RGBA16UI", Value: uint32(36214)},
			{Name: "GL_RGB16UI", Value: uint32(36215)},
			{Name: "GL_RGB16UI_EXT", Value: uint32(36215)},
			{Name: "GL_ALPHA16UI_EXT", Value: uint32(36216)},
			{Name: "GL_INTENSITY16UI_EXT", Value: uint32(36217)},
			{Name: "GL_LUMINANCE16UI_EXT", Value: uint32(36218)},
			{Name: "GL_LUMINANCE_ALPHA16UI_EXT", Value: uint32(36219)},
			{Name: "GL_RGBA8UI", Value: uint32(36220)},
			{Name: "GL_RGBA8UI_EXT", Value: uint32(36220)},
			{Name: "GL_RGB8UI_EXT", Value: uint32(36221)},
			{Name: "GL_RGB8UI", Value: uint32(36221)},
			{Name: "GL_ALPHA8UI_EXT", Value: uint32(36222)},
			{Name: "GL_INTENSITY8UI_EXT", Value: uint32(36223)},
			{Name: "GL_LUMINANCE8UI_EXT", Value: uint32(36224)},
			{Name: "GL_LUMINANCE_ALPHA8UI_EXT", Value: uint32(36225)},
			{Name: "GL_RGBA32I_EXT", Value: uint32(36226)},
			{Name: "GL_RGBA32I", Value: uint32(36226)},
			{Name: "GL_RGB32I", Value: uint32(36227)},
			{Name: "GL_RGB32I_EXT", Value: uint32(36227)},
			{Name: "GL_ALPHA32I_EXT", Value: uint32(36228)},
			{Name: "GL_INTENSITY32I_EXT", Value: uint32(36229)},
			{Name: "GL_LUMINANCE32I_EXT", Value: uint32(36230)},
			{Name: "GL_LUMINANCE_ALPHA32I_EXT", Value: uint32(36231)},
			{Name: "GL_RGBA16I", Value: uint32(36232)},
			{Name: "GL_RGBA16I_EXT", Value: uint32(36232)},
			{Name: "GL_RGB16I", Value: uint32(36233)},
			{Name: "GL_RGB16I_EXT", Value: uint32(36233)},
			{Name: "GL_ALPHA16I_EXT", Value: uint32(36234)},
			{Name: "GL_INTENSITY16I_EXT", Value: uint32(36235)},
			{Name: "GL_LUMINANCE16I_EXT", Value: uint32(36236)},
			{Name: "GL_LUMINANCE_ALPHA16I_EXT", Value: uint32(36237)},
			{Name: "GL_RGBA8I", Value: uint32(36238)},
			{Name: "GL_RGBA8I_EXT", Value: uint32(36238)},
			{Name: "GL_RGB8I_EXT", Value: uint32(36239)},
			{Name: "GL_RGB8I", Value: uint32(36239)},
			{Name: "GL_ALPHA8I_EXT", Value: uint32(36240)},
			{Name: "GL_INTENSITY8I_EXT", Value: uint32(36241)},
			{Name: "GL_LUMINANCE8I_EXT", Value: uint32(36242)},
			{Name: "GL_LUMINANCE_ALPHA8I_EXT", Value: uint32(36243)},
			{Name: "GL_RED_INTEGER", Value: uint32(36244)},
			{Name: "GL_RED_INTEGER_EXT", Value: uint32(36244)},
			{Name: "GL_GREEN_INTEGER_EXT", Value: uint32(36245)},
			{Name: "GL_GREEN_INTEGER", Value: uint32(36245)},
			{Name: "GL_BLUE_INTEGER_EXT", Value: uint32(36246)},
			{Name: "GL_BLUE_INTEGER", Value: uint32(36246)},
			{Name: "GL_ALPHA_INTEGER_EXT", Value: uint32(36247)},
			{Name: "GL_ALPHA_INTEGER", Value: uint32(36247)},
			{Name: "GL_RGB_INTEGER_EXT", Value: uint32(36248)},
			{Name: "GL_RGB_INTEGER", Value: uint32(36248)},
			{Name: "GL_RGBA_INTEGER", Value: uint32(36249)},
			{Name: "GL_RGBA_INTEGER_EXT", Value: uint32(36249)},
			{Name: "GL_BGR_INTEGER_EXT", Value: uint32(36250)},
			{Name: "GL_BGR_INTEGER", Value: uint32(36250)},
			{Name: "GL_BGRA_INTEGER", Value: uint32(36251)},
			{Name: "GL_BGRA_INTEGER_EXT", Value: uint32(36251)},
			{Name: "GL_LUMINANCE_INTEGER_EXT", Value: uint32(36252)},
			{Name: "GL_LUMINANCE_ALPHA_INTEGER_EXT", Value: uint32(36253)},
			{Name: "GL_RGBA_INTEGER_MODE_EXT", Value: uint32(36254)},
			{Name: "GL_INT_2_10_10_10_REV", Value: uint32(36255)},
			{Name: "GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV", Value: uint32(36256)},
			{Name: "GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV", Value: uint32(36257)},
			{Name: "GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(36258)},
			{Name: "GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(36259)},
			{Name: "GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(36260)},
			{Name: "GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV", Value: uint32(36261)},
			{Name: "GL_MAX_PROGRAM_GENERIC_RESULTS_NV", Value: uint32(36262)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB", Value: uint32(36263)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES", Value: uint32(36263)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT", Value: uint32(36263)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_LAYERED", Value: uint32(36263)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB", Value: uint32(36264)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES", Value: uint32(36264)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT", Value: uint32(36264)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS", Value: uint32(36264)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT", Value: uint32(36265)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB", Value: uint32(36265)},
			{Name: "GL_LAYER_NV", Value: uint32(36266)},
			{Name: "GL_DEPTH_COMPONENT32F_NV", Value: uint32(36267)},
			{Name: "GL_DEPTH32F_STENCIL8_NV", Value: uint32(36268)},
			{Name: "GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV", Value: uint32(36269)},
			{Name: "GL_FLOAT_32_UNSIGNED_INT_24_8_REV", Value: uint32(36269)},
			{Name: "GL_SHADER_INCLUDE_ARB", Value: uint32(36270)},
			{Name: "GL_DEPTH_BUFFER_FLOAT_MODE_NV", Value: uint32(36271)},
			{Name: "GL_FRAMEBUFFER_SRGB", Value: uint32(36281)},
			{Name: "GL_FRAMEBUFFER_SRGB_EXT", Value: uint32(36281)},
			{Name: "GL_FRAMEBUFFER_SRGB_CAPABLE_EXT", Value: uint32(36282)},
			{Name: "GL_COMPRESSED_RED_RGTC1_EXT", Value: uint32(36283)},
			{Name: "GL_COMPRESSED_RED_RGTC1", Value: uint32(36283)},
			{Name: "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT", Value: uint32(36284)},
			{Name: "GL_COMPRESSED_SIGNED_RED_RGTC1", Value: uint32(36284)},
			{Name: "GL_COMPRESSED_RG_RGTC2", Value: uint32(36285)},
			{Name: "GL_COMPRESSED_RED_GREEN_RGTC2_EXT", Value: uint32(36285)},
			{Name: "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT", Value: uint32(36286)},
			{Name: "GL_COMPRESSED_SIGNED_RG_RGTC2", Value: uint32(36286)},
			{Name: "GL_SAMPLER_1D_ARRAY", Value: uint32(36288)},
			{Name: "GL_SAMPLER_1D_ARRAY_EXT", Value: uint32(36288)},
			{Name: "GL_SAMPLER_2D_ARRAY", Value: uint32(36289)},
			{Name: "GL_SAMPLER_2D_ARRAY_EXT", Value: uint32(36289)},
			{Name: "GL_SAMPLER_BUFFER", Value: uint32(36290)},
			{Name: "GL_SAMPLER_BUFFER_EXT", Value: uint32(36290)},
			{Name: "GL_SAMPLER_BUFFER_OES", Value: uint32(36290)},
			{Name: "GL_SAMPLER_1D_ARRAY_SHADOW", Value: uint32(36291)},
			{Name: "GL_SAMPLER_1D_ARRAY_SHADOW_EXT", Value: uint32(36291)},
			{Name: "GL_SAMPLER_2D_ARRAY_SHADOW", Value: uint32(36292)},
			{Name: "GL_SAMPLER_2D_ARRAY_SHADOW_NV", Value: uint32(36292)},
			{Name: "GL_SAMPLER_2D_ARRAY_SHADOW_EXT", Value: uint32(36292)},
			{Name: "GL_SAMPLER_CUBE_SHADOW", Value: uint32(36293)},
			{Name: "GL_SAMPLER_CUBE_SHADOW_EXT", Value: uint32(36293)},
			{Name: "GL_SAMPLER_CUBE_SHADOW_NV", Value: uint32(36293)},
			{Name: "GL_UNSIGNED_INT_VEC2_EXT", Value: uint32(36294)},
			{Name: "GL_UNSIGNED_INT_VEC2", Value: uint32(36294)},
			{Name: "GL_UNSIGNED_INT_VEC3_EXT", Value: uint32(36295)},
			{Name: "GL_UNSIGNED_INT_VEC3", Value: uint32(36295)},
			{Name: "GL_UNSIGNED_INT_VEC4", Value: uint32(36296)},
			{Name: "GL_UNSIGNED_INT_VEC4_EXT", Value: uint32(36296)},
			{Name: "GL_INT_SAMPLER_1D_EXT", Value: uint32(36297)},
			{Name: "GL_INT_SAMPLER_1D", Value: uint32(36297)},
			{Name: "GL_INT_SAMPLER_2D", Value: uint32(36298)},
			{Name: "GL_INT_SAMPLER_2D_EXT", Value: uint32(36298)},
			{Name: "GL_INT_SAMPLER_3D", Value: uint32(36299)},
			{Name: "GL_INT_SAMPLER_3D_EXT", Value: uint32(36299)},
			{Name: "GL_INT_SAMPLER_CUBE", Value: uint32(36300)},
			{Name: "GL_INT_SAMPLER_CUBE_EXT", Value: uint32(36300)},
			{Name: "GL_INT_SAMPLER_2D_RECT", Value: uint32(36301)},
			{Name: "GL_INT_SAMPLER_2D_RECT_EXT", Value: uint32(36301)},
			{Name: "GL_INT_SAMPLER_1D_ARRAY", Value: uint32(36302)},
			{Name: "GL_INT_SAMPLER_1D_ARRAY_EXT", Value: uint32(36302)},
			{Name: "GL_INT_SAMPLER_2D_ARRAY", Value: uint32(36303)},
			{Name: "GL_INT_SAMPLER_2D_ARRAY_EXT", Value: uint32(36303)},
			{Name: "GL_INT_SAMPLER_BUFFER", Value: uint32(36304)},
			{Name: "GL_INT_SAMPLER_BUFFER_OES", Value: uint32(36304)},
			{Name: "GL_INT_SAMPLER_BUFFER_EXT", Value: uint32(36304)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_1D_EXT", Value: uint32(36305)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_1D", Value: uint32(36305)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D", Value: uint32(36306)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_EXT", Value: uint32(36306)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_3D", Value: uint32(36307)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_3D_EXT", Value: uint32(36307)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE", Value: uint32(36308)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE_EXT", Value: uint32(36308)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT", Value: uint32(36309)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_RECT", Value: uint32(36309)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY", Value: uint32(36310)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT", Value: uint32(36310)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY", Value: uint32(36311)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT", Value: uint32(36311)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT", Value: uint32(36312)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_BUFFER", Value: uint32(36312)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_BUFFER_OES", Value: uint32(36312)},
			{Name: "GL_GEOMETRY_SHADER_EXT", Value: uint32(36313)},
			{Name: "GL_GEOMETRY_SHADER_ARB", Value: uint32(36313)},
			{Name: "GL_GEOMETRY_SHADER", Value: uint32(36313)},
			{Name: "GL_GEOMETRY_SHADER_OES", Value: uint32(36313)},
			{Name: "GL_GEOMETRY_VERTICES_OUT_EXT", Value: uint32(36314)},
			{Name: "GL_GEOMETRY_VERTICES_OUT_ARB", Value: uint32(36314)},
			{Name: "GL_GEOMETRY_INPUT_TYPE_ARB", Value: uint32(36315)},
			{Name: "GL_GEOMETRY_INPUT_TYPE_EXT", Value: uint32(36315)},
			{Name: "GL_GEOMETRY_OUTPUT_TYPE_ARB", Value: uint32(36316)},
			{Name: "GL_GEOMETRY_OUTPUT_TYPE_EXT", Value: uint32(36316)},
			{Name: "GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT", Value: uint32(36317)},
			{Name: "GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB", Value: uint32(36317)},
			{Name: "GL_MAX_VERTEX_VARYING_COMPONENTS_EXT", Value: uint32(36318)},
			{Name: "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB", Value: uint32(36318)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES", Value: uint32(36319)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS", Value: uint32(36319)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB", Value: uint32(36319)},
			{Name: "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT", Value: uint32(36319)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_VERTICES", Value: uint32(36320)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES", Value: uint32(36320)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT", Value: uint32(36320)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB", Value: uint32(36320)},
			{Name: "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES", Value: uint32(36321)},
			{Name: "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT", Value: uint32(36321)},
			{Name: "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS", Value: uint32(36321)},
			{Name: "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB", Value: uint32(36321)},
			{Name: "GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT", Value: uint32(36322)},
			{Name: "GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT", Value: uint32(36323)},
			{Name: "GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT", Value: uint32(36324)},
			{Name: "GL_ACTIVE_SUBROUTINES", Value: uint32(36325)},
			{Name: "GL_ACTIVE_SUBROUTINE_UNIFORMS", Value: uint32(36326)},
			{Name: "GL_MAX_SUBROUTINES", Value: uint32(36327)},
			{Name: "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS", Value: uint32(36328)},
			{Name: "GL_NAMED_STRING_LENGTH_ARB", Value: uint32(36329)},
			{Name: "GL_NAMED_STRING_TYPE_ARB", Value: uint32(36330)},
			{Name: "GL_MAX_BINDABLE_UNIFORM_SIZE_EXT", Value: uint32(36333)},
			{Name: "GL_UNIFORM_BUFFER_EXT", Value: uint32(36334)},
			{Name: "GL_UNIFORM_BUFFER_BINDING_EXT", Value: uint32(36335)},
			{Name: "GL_LOW_FLOAT", Value: uint32(36336)},
			{Name: "GL_MEDIUM_FLOAT", Value: uint32(36337)},
			{Name: "GL_HIGH_FLOAT", Value: uint32(36338)},
			{Name: "GL_LOW_INT", Value: uint32(36339)},
			{Name: "GL_MEDIUM_INT", Value: uint32(36340)},
			{Name: "GL_HIGH_INT", Value: uint32(36341)},
			{Name: "GL_UNSIGNED_INT_10_10_10_2_OES", Value: uint32(36342)},
			{Name: "GL_INT_10_10_10_2_OES", Value: uint32(36343)},
			{Name: "GL_SHADER_BINARY_FORMATS", Value: uint32(36344)},
			{Name: "GL_NUM_SHADER_BINARY_FORMATS", Value: uint32(36345)},
			{Name: "GL_SHADER_COMPILER", Value: uint32(36346)},
			{Name: "GL_MAX_VERTEX_UNIFORM_VECTORS", Value: uint32(36347)},
			{Name: "GL_MAX_VARYING_VECTORS", Value: uint32(36348)},
			{Name: "GL_MAX_FRAGMENT_UNIFORM_VECTORS", Value: uint32(36349)},
			{Name: "GL_RENDERBUFFER_COLOR_SAMPLES_NV", Value: uint32(36368)},
			{Name: "GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV", Value: uint32(36369)},
			{Name: "GL_MULTISAMPLE_COVERAGE_MODES_NV", Value: uint32(36370)},
			{Name: "GL_QUERY_WAIT_NV", Value: uint32(36371)},
			{Name: "GL_QUERY_WAIT", Value: uint32(36371)},
			{Name: "GL_QUERY_NO_WAIT_NV", Value: uint32(36372)},
			{Name: "GL_QUERY_NO_WAIT", Value: uint32(36372)},
			{Name: "GL_QUERY_BY_REGION_WAIT", Value: uint32(36373)},
			{Name: "GL_QUERY_BY_REGION_WAIT_NV", Value: uint32(36373)},
			{Name: "GL_QUERY_BY_REGION_NO_WAIT", Value: uint32(36374)},
			{Name: "GL_QUERY_BY_REGION_NO_WAIT_NV", Value: uint32(36374)},
			{Name: "GL_QUERY_WAIT_INVERTED", Value: uint32(36375)},
			{Name: "GL_QUERY_NO_WAIT_INVERTED", Value: uint32(36376)},
			{Name: "GL_QUERY_BY_REGION_WAIT_INVERTED", Value: uint32(36377)},
			{Name: "GL_QUERY_BY_REGION_NO_WAIT_INVERTED", Value: uint32(36378)},
			{Name: "GL_POLYGON_OFFSET_CLAMP_EXT", Value: uint32(36379)},
			{Name: "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES", Value: uint32(36382)},
			{Name: "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", Value: uint32(36382)},
			{Name: "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS", Value: uint32(36382)},
			{Name: "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", Value: uint32(36383)},
			{Name: "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES", Value: uint32(36383)},
			{Name: "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS", Value: uint32(36383)},
			{Name: "GL_COLOR_SAMPLES_NV", Value: uint32(36384)},
			{Name: "GL_TRANSFORM_FEEDBACK", Value: uint32(36386)},
			{Name: "GL_TRANSFORM_FEEDBACK_NV", Value: uint32(36386)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV", Value: uint32(36387)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED", Value: uint32(36387)},
			{Name: "GL_TRANSFORM_FEEDBACK_PAUSED", Value: uint32(36387)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE", Value: uint32(36388)},
			{Name: "GL_TRANSFORM_FEEDBACK_ACTIVE", Value: uint32(36388)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV", Value: uint32(36388)},
			{Name: "GL_TRANSFORM_FEEDBACK_BINDING_NV", Value: uint32(36389)},
			{Name: "GL_TRANSFORM_FEEDBACK_BINDING", Value: uint32(36389)},
			{Name: "GL_FRAME_NV", Value: uint32(36390)},
			{Name: "GL_FIELDS_NV", Value: uint32(36391)},
			{Name: "GL_TIMESTAMP_EXT", Value: uint32(36392)},
			{Name: "GL_CURRENT_TIME_NV", Value: uint32(36392)},
			{Name: "GL_TIMESTAMP", Value: uint32(36392)},
			{Name: "GL_NUM_FILL_STREAMS_NV", Value: uint32(36393)},
			{Name: "GL_PRESENT_TIME_NV", Value: uint32(36394)},
			{Name: "GL_PRESENT_DURATION_NV", Value: uint32(36395)},
			{Name: "GL_DEPTH_COMPONENT16_NONLINEAR_NV", Value: uint32(36396)},
			{Name: "GL_PROGRAM_MATRIX_EXT", Value: uint32(36397)},
			{Name: "GL_TRANSPOSE_PROGRAM_MATRIX_EXT", Value: uint32(36398)},
			{Name: "GL_PROGRAM_MATRIX_STACK_DEPTH_EXT", Value: uint32(36399)},
			{Name: "GL_TEXTURE_SWIZZLE_R", Value: uint32(36418)},
			{Name: "GL_TEXTURE_SWIZZLE_R_EXT", Value: uint32(36418)},
			{Name: "GL_TEXTURE_SWIZZLE_G", Value: uint32(36419)},
			{Name: "GL_TEXTURE_SWIZZLE_G_EXT", Value: uint32(36419)},
			{Name: "GL_TEXTURE_SWIZZLE_B_EXT", Value: uint32(36420)},
			{Name: "GL_TEXTURE_SWIZZLE_B", Value: uint32(36420)},
			{Name: "GL_TEXTURE_SWIZZLE_A_EXT", Value: uint32(36421)},
			{Name: "GL_TEXTURE_SWIZZLE_A", Value: uint32(36421)},
			{Name: "GL_TEXTURE_SWIZZLE_RGBA_EXT", Value: uint32(36422)},
			{Name: "GL_TEXTURE_SWIZZLE_RGBA", Value: uint32(36422)},
			{Name: "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS", Value: uint32(36423)},
			{Name: "GL_ACTIVE_SUBROUTINE_MAX_LENGTH", Value: uint32(36424)},
			{Name: "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH", Value: uint32(36425)},
			{Name: "GL_NUM_COMPATIBLE_SUBROUTINES", Value: uint32(36426)},
			{Name: "GL_COMPATIBLE_SUBROUTINES", Value: uint32(36427)},
			{Name: "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION", Value: uint32(36428)},
			{Name: "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT", Value: uint32(36428)},
			{Name: "GL_FIRST_VERTEX_CONVENTION_OES", Value: uint32(36429)},
			{Name: "GL_FIRST_VERTEX_CONVENTION", Value: uint32(36429)},
			{Name: "GL_FIRST_VERTEX_CONVENTION_EXT", Value: uint32(36429)},
			{Name: "GL_LAST_VERTEX_CONVENTION_EXT", Value: uint32(36430)},
			{Name: "GL_LAST_VERTEX_CONVENTION", Value: uint32(36430)},
			{Name: "GL_LAST_VERTEX_CONVENTION_OES", Value: uint32(36430)},
			{Name: "GL_PROVOKING_VERTEX", Value: uint32(36431)},
			{Name: "GL_PROVOKING_VERTEX_EXT", Value: uint32(36431)},
			{Name: "GL_SAMPLE_POSITION_NV", Value: uint32(36432)},
			{Name: "GL_SAMPLE_POSITION", Value: uint32(36432)},
			{Name: "GL_SAMPLE_LOCATION_NV", Value: uint32(36432)},
			{Name: "GL_SAMPLE_MASK_NV", Value: uint32(36433)},
			{Name: "GL_SAMPLE_MASK", Value: uint32(36433)},
			{Name: "GL_SAMPLE_MASK_VALUE_NV", Value: uint32(36434)},
			{Name: "GL_SAMPLE_MASK_VALUE", Value: uint32(36434)},
			{Name: "GL_TEXTURE_BINDING_RENDERBUFFER_NV", Value: uint32(36435)},
			{Name: "GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV", Value: uint32(36436)},
			{Name: "GL_TEXTURE_RENDERBUFFER_NV", Value: uint32(36437)},
			{Name: "GL_SAMPLER_RENDERBUFFER_NV", Value: uint32(36438)},
			{Name: "GL_INT_SAMPLER_RENDERBUFFER_NV", Value: uint32(36439)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV", Value: uint32(36440)},
			{Name: "GL_MAX_SAMPLE_MASK_WORDS_NV", Value: uint32(36441)},
			{Name: "GL_MAX_SAMPLE_MASK_WORDS", Value: uint32(36441)},
			{Name: "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT", Value: uint32(36442)},
			{Name: "GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES", Value: uint32(36442)},
			{Name: "GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV", Value: uint32(36442)},
			{Name: "GL_MAX_GEOMETRY_SHADER_INVOCATIONS", Value: uint32(36442)},
			{Name: "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV", Value: uint32(36443)},
			{Name: "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES", Value: uint32(36443)},
			{Name: "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET", Value: uint32(36443)},
			{Name: "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES", Value: uint32(36444)},
			{Name: "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET", Value: uint32(36444)},
			{Name: "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV", Value: uint32(36444)},
			{Name: "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES", Value: uint32(36445)},
			{Name: "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS", Value: uint32(36445)},
			{Name: "GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV", Value: uint32(36445)},
			{Name: "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET", Value: uint32(36446)},
			{Name: "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB", Value: uint32(36446)},
			{Name: "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV", Value: uint32(36446)},
			{Name: "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB", Value: uint32(36447)},
			{Name: "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET", Value: uint32(36447)},
			{Name: "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV", Value: uint32(36447)},
			{Name: "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS", Value: uint32(36464)},
			{Name: "GL_MAX_VERTEX_STREAMS", Value: uint32(36465)},
			{Name: "GL_PATCH_VERTICES_OES", Value: uint32(36466)},
			{Name: "GL_PATCH_VERTICES", Value: uint32(36466)},
			{Name: "GL_PATCH_VERTICES_EXT", Value: uint32(36466)},
			{Name: "GL_PATCH_DEFAULT_INNER_LEVEL", Value: uint32(36467)},
			{Name: "GL_PATCH_DEFAULT_INNER_LEVEL_EXT", Value: uint32(36467)},
			{Name: "GL_PATCH_DEFAULT_OUTER_LEVEL", Value: uint32(36468)},
			{Name: "GL_PATCH_DEFAULT_OUTER_LEVEL_EXT", Value: uint32(36468)},
			{Name: "GL_TESS_CONTROL_OUTPUT_VERTICES_EXT", Value: uint32(36469)},
			{Name: "GL_TESS_CONTROL_OUTPUT_VERTICES", Value: uint32(36469)},
			{Name: "GL_TESS_CONTROL_OUTPUT_VERTICES_OES", Value: uint32(36469)},
			{Name: "GL_TESS_GEN_MODE_EXT", Value: uint32(36470)},
			{Name: "GL_TESS_GEN_MODE_OES", Value: uint32(36470)},
			{Name: "GL_TESS_GEN_MODE", Value: uint32(36470)},
			{Name: "GL_TESS_GEN_SPACING_OES", Value: uint32(36471)},
			{Name: "GL_TESS_GEN_SPACING_EXT", Value: uint32(36471)},
			{Name: "GL_TESS_GEN_SPACING", Value: uint32(36471)},
			{Name: "GL_TESS_GEN_VERTEX_ORDER_EXT", Value: uint32(36472)},
			{Name: "GL_TESS_GEN_VERTEX_ORDER_OES", Value: uint32(36472)},
			{Name: "GL_TESS_GEN_VERTEX_ORDER", Value: uint32(36472)},
			{Name: "GL_TESS_GEN_POINT_MODE_EXT", Value: uint32(36473)},
			{Name: "GL_TESS_GEN_POINT_MODE_OES", Value: uint32(36473)},
			{Name: "GL_TESS_GEN_POINT_MODE", Value: uint32(36473)},
			{Name: "GL_ISOLINES_EXT", Value: uint32(36474)},
			{Name: "GL_ISOLINES_OES", Value: uint32(36474)},
			{Name: "GL_ISOLINES", Value: uint32(36474)},
			{Name: "GL_FRACTIONAL_ODD", Value: uint32(36475)},
			{Name: "GL_FRACTIONAL_ODD_EXT", Value: uint32(36475)},
			{Name: "GL_FRACTIONAL_ODD_OES", Value: uint32(36475)},
			{Name: "GL_FRACTIONAL_EVEN", Value: uint32(36476)},
			{Name: "GL_FRACTIONAL_EVEN_OES", Value: uint32(36476)},
			{Name: "GL_FRACTIONAL_EVEN_EXT", Value: uint32(36476)},
			{Name: "GL_MAX_PATCH_VERTICES_EXT", Value: uint32(36477)},
			{Name: "GL_MAX_PATCH_VERTICES_OES", Value: uint32(36477)},
			{Name: "GL_MAX_PATCH_VERTICES", Value: uint32(36477)},
			{Name: "GL_MAX_TESS_GEN_LEVEL_OES", Value: uint32(36478)},
			{Name: "GL_MAX_TESS_GEN_LEVEL", Value: uint32(36478)},
			{Name: "GL_MAX_TESS_GEN_LEVEL_EXT", Value: uint32(36478)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS", Value: uint32(36479)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES", Value: uint32(36479)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT", Value: uint32(36479)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES", Value: uint32(36480)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT", Value: uint32(36480)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS", Value: uint32(36480)},
			{Name: "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES", Value: uint32(36481)},
			{Name: "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS", Value: uint32(36481)},
			{Name: "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT", Value: uint32(36481)},
			{Name: "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS", Value: uint32(36482)},
			{Name: "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT", Value: uint32(36482)},
			{Name: "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES", Value: uint32(36482)},
			{Name: "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES", Value: uint32(36483)},
			{Name: "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS", Value: uint32(36483)},
			{Name: "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT", Value: uint32(36483)},
			{Name: "GL_MAX_TESS_PATCH_COMPONENTS_EXT", Value: uint32(36484)},
			{Name: "GL_MAX_TESS_PATCH_COMPONENTS", Value: uint32(36484)},
			{Name: "GL_MAX_TESS_PATCH_COMPONENTS_OES", Value: uint32(36484)},
			{Name: "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT", Value: uint32(36485)},
			{Name: "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES", Value: uint32(36485)},
			{Name: "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS", Value: uint32(36485)},
			{Name: "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS", Value: uint32(36486)},
			{Name: "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES", Value: uint32(36486)},
			{Name: "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT", Value: uint32(36486)},
			{Name: "GL_TESS_EVALUATION_SHADER", Value: uint32(36487)},
			{Name: "GL_TESS_EVALUATION_SHADER_EXT", Value: uint32(36487)},
			{Name: "GL_TESS_EVALUATION_SHADER_OES", Value: uint32(36487)},
			{Name: "GL_TESS_CONTROL_SHADER_EXT", Value: uint32(36488)},
			{Name: "GL_TESS_CONTROL_SHADER_OES", Value: uint32(36488)},
			{Name: "GL_TESS_CONTROL_SHADER", Value: uint32(36488)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT", Value: uint32(36489)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS", Value: uint32(36489)},
			{Name: "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES", Value: uint32(36489)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES", Value: uint32(36490)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT", Value: uint32(36490)},
			{Name: "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS", Value: uint32(36490)},
			{Name: "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB", Value: uint32(36492)},
			{Name: "GL_COMPRESSED_RGBA_BPTC_UNORM", Value: uint32(36492)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM", Value: uint32(36493)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB", Value: uint32(36493)},
			{Name: "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT", Value: uint32(36494)},
			{Name: "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB", Value: uint32(36494)},
			{Name: "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT", Value: uint32(36495)},
			{Name: "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB", Value: uint32(36495)},
			{Name: "GL_COVERAGE_COMPONENT_NV", Value: uint32(36560)},
			{Name: "GL_COVERAGE_COMPONENT4_NV", Value: uint32(36561)},
			{Name: "GL_COVERAGE_ATTACHMENT_NV", Value: uint32(36562)},
			{Name: "GL_COVERAGE_BUFFERS_NV", Value: uint32(36563)},
			{Name: "GL_COVERAGE_SAMPLES_NV", Value: uint32(36564)},
			{Name: "GL_COVERAGE_ALL_FRAGMENTS_NV", Value: uint32(36565)},
			{Name: "GL_COVERAGE_EDGE_FRAGMENTS_NV", Value: uint32(36566)},
			{Name: "GL_COVERAGE_AUTOMATIC_NV", Value: uint32(36567)},
			{Name: "GL_BUFFER_GPU_ADDRESS_NV", Value: uint32(36637)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV", Value: uint32(36638)},
			{Name: "GL_ELEMENT_ARRAY_UNIFIED_NV", Value: uint32(36639)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV", Value: uint32(36640)},
			{Name: "GL_VERTEX_ARRAY_ADDRESS_NV", Value: uint32(36641)},
			{Name: "GL_NORMAL_ARRAY_ADDRESS_NV", Value: uint32(36642)},
			{Name: "GL_COLOR_ARRAY_ADDRESS_NV", Value: uint32(36643)},
			{Name: "GL_INDEX_ARRAY_ADDRESS_NV", Value: uint32(36644)},
			{Name: "GL_TEXTURE_COORD_ARRAY_ADDRESS_NV", Value: uint32(36645)},
			{Name: "GL_EDGE_FLAG_ARRAY_ADDRESS_NV", Value: uint32(36646)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV", Value: uint32(36647)},
			{Name: "GL_FOG_COORD_ARRAY_ADDRESS_NV", Value: uint32(36648)},
			{Name: "GL_ELEMENT_ARRAY_ADDRESS_NV", Value: uint32(36649)},
			{Name: "GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV", Value: uint32(36650)},
			{Name: "GL_VERTEX_ARRAY_LENGTH_NV", Value: uint32(36651)},
			{Name: "GL_NORMAL_ARRAY_LENGTH_NV", Value: uint32(36652)},
			{Name: "GL_COLOR_ARRAY_LENGTH_NV", Value: uint32(36653)},
			{Name: "GL_INDEX_ARRAY_LENGTH_NV", Value: uint32(36654)},
			{Name: "GL_TEXTURE_COORD_ARRAY_LENGTH_NV", Value: uint32(36655)},
			{Name: "GL_EDGE_FLAG_ARRAY_LENGTH_NV", Value: uint32(36656)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_LENGTH_NV", Value: uint32(36657)},
			{Name: "GL_FOG_COORD_ARRAY_LENGTH_NV", Value: uint32(36658)},
			{Name: "GL_ELEMENT_ARRAY_LENGTH_NV", Value: uint32(36659)},
			{Name: "GL_GPU_ADDRESS_NV", Value: uint32(36660)},
			{Name: "GL_MAX_SHADER_BUFFER_ADDRESS_NV", Value: uint32(36661)},
			{Name: "GL_COPY_READ_BUFFER_NV", Value: uint32(36662)},
			{Name: "GL_COPY_READ_BUFFER_BINDING", Value: uint32(36662)},
			{Name: "GL_COPY_READ_BUFFER", Value: uint32(36662)},
			{Name: "GL_COPY_WRITE_BUFFER_NV", Value: uint32(36663)},
			{Name: "GL_COPY_WRITE_BUFFER", Value: uint32(36663)},
			{Name: "GL_COPY_WRITE_BUFFER_BINDING", Value: uint32(36663)},
			{Name: "GL_MAX_IMAGE_UNITS_EXT", Value: uint32(36664)},
			{Name: "GL_MAX_IMAGE_UNITS", Value: uint32(36664)},
			{Name: "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS", Value: uint32(36665)},
			{Name: "GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES", Value: uint32(36665)},
			{Name: "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT", Value: uint32(36665)},
			{Name: "GL_IMAGE_BINDING_NAME", Value: uint32(36666)},
			{Name: "GL_IMAGE_BINDING_NAME_EXT", Value: uint32(36666)},
			{Name: "GL_IMAGE_BINDING_LEVEL", Value: uint32(36667)},
			{Name: "GL_IMAGE_BINDING_LEVEL_EXT", Value: uint32(36667)},
			{Name: "GL_IMAGE_BINDING_LAYERED", Value: uint32(36668)},
			{Name: "GL_IMAGE_BINDING_LAYERED_EXT", Value: uint32(36668)},
			{Name: "GL_IMAGE_BINDING_LAYER_EXT", Value: uint32(36669)},
			{Name: "GL_IMAGE_BINDING_LAYER", Value: uint32(36669)},
			{Name: "GL_IMAGE_BINDING_ACCESS", Value: uint32(36670)},
			{Name: "GL_IMAGE_BINDING_ACCESS_EXT", Value: uint32(36670)},
			{Name: "GL_DRAW_INDIRECT_BUFFER", Value: uint32(36671)},
			{Name: "GL_DRAW_INDIRECT_UNIFIED_NV", Value: uint32(36672)},
			{Name: "GL_DRAW_INDIRECT_ADDRESS_NV", Value: uint32(36673)},
			{Name: "GL_DRAW_INDIRECT_LENGTH_NV", Value: uint32(36674)},
			{Name: "GL_DRAW_INDIRECT_BUFFER_BINDING", Value: uint32(36675)},
			{Name: "GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV", Value: uint32(36676)},
			{Name: "GL_MAX_PROGRAM_SUBROUTINE_NUM_NV", Value: uint32(36677)},
			{Name: "GL_DOUBLE_MAT2_EXT", Value: uint32(36678)},
			{Name: "GL_DOUBLE_MAT2", Value: uint32(36678)},
			{Name: "GL_DOUBLE_MAT3_EXT", Value: uint32(36679)},
			{Name: "GL_DOUBLE_MAT3", Value: uint32(36679)},
			{Name: "GL_DOUBLE_MAT4_EXT", Value: uint32(36680)},
			{Name: "GL_DOUBLE_MAT4", Value: uint32(36680)},
			{Name: "GL_DOUBLE_MAT2x3_EXT", Value: uint32(36681)},
			{Name: "GL_DOUBLE_MAT2x3", Value: uint32(36681)},
			{Name: "GL_DOUBLE_MAT2x4_EXT", Value: uint32(36682)},
			{Name: "GL_DOUBLE_MAT2x4", Value: uint32(36682)},
			{Name: "GL_DOUBLE_MAT3x2", Value: uint32(36683)},
			{Name: "GL_DOUBLE_MAT3x2_EXT", Value: uint32(36683)},
			{Name: "GL_DOUBLE_MAT3x4_EXT", Value: uint32(36684)},
			{Name: "GL_DOUBLE_MAT3x4", Value: uint32(36684)},
			{Name: "GL_DOUBLE_MAT4x2", Value: uint32(36685)},
			{Name: "GL_DOUBLE_MAT4x2_EXT", Value: uint32(36685)},
			{Name: "GL_DOUBLE_MAT4x3_EXT", Value: uint32(36686)},
			{Name: "GL_DOUBLE_MAT4x3", Value: uint32(36686)},
			{Name: "GL_VERTEX_BINDING_BUFFER", Value: uint32(36687)},
			{Name: "GL_MALI_SHADER_BINARY_ARM", Value: uint32(36704)},
			{Name: "GL_MALI_PROGRAM_BINARY_ARM", Value: uint32(36705)},
			{Name: "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT", Value: uint32(36707)},
			{Name: "GL_SHADER_PIXEL_LOCAL_STORAGE_EXT", Value: uint32(36708)},
			{Name: "GL_FETCH_PER_SAMPLE_ARM", Value: uint32(36709)},
			{Name: "GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM", Value: uint32(36710)},
			{Name: "GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT", Value: uint32(36711)},
			{Name: "GL_RED_SNORM", Value: uint32(36752)},
			{Name: "GL_RG_SNORM", Value: uint32(36753)},
			{Name: "GL_RGB_SNORM", Value: uint32(36754)},
			{Name: "GL_RGBA_SNORM", Value: uint32(36755)},
			{Name: "GL_R8_SNORM", Value: uint32(36756)},
			{Name: "GL_RG8_SNORM", Value: uint32(36757)},
			{Name: "GL_RGB8_SNORM", Value: uint32(36758)},
			{Name: "GL_RGBA8_SNORM", Value: uint32(36759)},
			{Name: "GL_R16_SNORM_EXT", Value: uint32(36760)},
			{Name: "GL_R16_SNORM", Value: uint32(36760)},
			{Name: "GL_RG16_SNORM", Value: uint32(36761)},
			{Name: "GL_RG16_SNORM_EXT", Value: uint32(36761)},
			{Name: "GL_RGB16_SNORM", Value: uint32(36762)},
			{Name: "GL_RGB16_SNORM_EXT", Value: uint32(36762)},
			{Name: "GL_RGBA16_SNORM_EXT", Value: uint32(36763)},
			{Name: "GL_RGBA16_SNORM", Value: uint32(36763)},
			{Name: "GL_SIGNED_NORMALIZED", Value: uint32(36764)},
			{Name: "GL_PRIMITIVE_RESTART", Value: uint32(36765)},
			{Name: "GL_PRIMITIVE_RESTART_INDEX", Value: uint32(36766)},
			{Name: "GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB", Value: uint32(36767)},
			{Name: "GL_PERFMON_GLOBAL_MODE_QCOM", Value: uint32(36768)},
			{Name: "GL_BINNING_CONTROL_HINT_QCOM", Value: uint32(36784)},
			{Name: "GL_CPU_OPTIMIZED_QCOM", Value: uint32(36785)},
			{Name: "GL_GPU_OPTIMIZED_QCOM", Value: uint32(36786)},
			{Name: "GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM", Value: uint32(36787)},
			{Name: "GL_GPU_DISJOINT_EXT", Value: uint32(36795)},
			{Name: "GL_SR8_EXT", Value: uint32(36797)},
			{Name: "GL_SRG8_EXT", Value: uint32(36798)},
			{Name: "GL_SHADER_BINARY_VIV", Value: uint32(36804)},
			{Name: "GL_INT8_NV", Value: uint32(36832)},
			{Name: "GL_INT8_VEC2_NV", Value: uint32(36833)},
			{Name: "GL_INT8_VEC3_NV", Value: uint32(36834)},
			{Name: "GL_INT8_VEC4_NV", Value: uint32(36835)},
			{Name: "GL_INT16_NV", Value: uint32(36836)},
			{Name: "GL_INT16_VEC2_NV", Value: uint32(36837)},
			{Name: "GL_INT16_VEC3_NV", Value: uint32(36838)},
			{Name: "GL_INT16_VEC4_NV", Value: uint32(36839)},
			{Name: "GL_INT64_VEC2_NV", Value: uint32(36841)},
			{Name: "GL_INT64_VEC3_NV", Value: uint32(36842)},
			{Name: "GL_INT64_VEC4_NV", Value: uint32(36843)},
			{Name: "GL_UNSIGNED_INT8_NV", Value: uint32(36844)},
			{Name: "GL_UNSIGNED_INT8_VEC2_NV", Value: uint32(36845)},
			{Name: "GL_UNSIGNED_INT8_VEC3_NV", Value: uint32(36846)},
			{Name: "GL_UNSIGNED_INT8_VEC4_NV", Value: uint32(36847)},
			{Name: "GL_UNSIGNED_INT16_NV", Value: uint32(36848)},
			{Name: "GL_UNSIGNED_INT16_VEC2_NV", Value: uint32(36849)},
			{Name: "GL_UNSIGNED_INT16_VEC3_NV", Value: uint32(36850)},
			{Name: "GL_UNSIGNED_INT16_VEC4_NV", Value: uint32(36851)},
			{Name: "GL_UNSIGNED_INT64_VEC2_NV", Value: uint32(36853)},
			{Name: "GL_UNSIGNED_INT64_VEC3_NV", Value: uint32(36854)},
			{Name: "GL_UNSIGNED_INT64_VEC4_NV", Value: uint32(36855)},
			{Name: "GL_FLOAT16_NV", Value: uint32(36856)},
			{Name: "GL_FLOAT16_VEC2_NV", Value: uint32(36857)},
			{Name: "GL_FLOAT16_VEC3_NV", Value: uint32(36858)},
			{Name: "GL_FLOAT16_VEC4_NV", Value: uint32(36859)},
			{Name: "GL_DOUBLE_VEC2", Value: uint32(36860)},
			{Name: "GL_DOUBLE_VEC2_EXT", Value: uint32(36860)},
			{Name: "GL_DOUBLE_VEC3_EXT", Value: uint32(36861)},
			{Name: "GL_DOUBLE_VEC3", Value: uint32(36861)},
			{Name: "GL_DOUBLE_VEC4_EXT", Value: uint32(36862)},
			{Name: "GL_DOUBLE_VEC4", Value: uint32(36862)},
			{Name: "GL_SAMPLER_BUFFER_AMD", Value: uint32(36865)},
			{Name: "GL_INT_SAMPLER_BUFFER_AMD", Value: uint32(36866)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD", Value: uint32(36867)},
			{Name: "GL_TESSELLATION_MODE_AMD", Value: uint32(36868)},
			{Name: "GL_TESSELLATION_FACTOR_AMD", Value: uint32(36869)},
			{Name: "GL_DISCRETE_AMD", Value: uint32(36870)},
			{Name: "GL_CONTINUOUS_AMD", Value: uint32(36871)},
			{Name: "GL_TEXTURE_CUBE_MAP_ARRAY_OES", Value: uint32(36873)},
			{Name: "GL_TEXTURE_CUBE_MAP_ARRAY", Value: uint32(36873)},
			{Name: "GL_TEXTURE_CUBE_MAP_ARRAY_EXT", Value: uint32(36873)},
			{Name: "GL_TEXTURE_CUBE_MAP_ARRAY_ARB", Value: uint32(36873)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY", Value: uint32(36874)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES", Value: uint32(36874)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT", Value: uint32(36874)},
			{Name: "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB", Value: uint32(36874)},
			{Name: "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY", Value: uint32(36875)},
			{Name: "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB", Value: uint32(36875)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_ARB", Value: uint32(36876)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_OES", Value: uint32(36876)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_EXT", Value: uint32(36876)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY", Value: uint32(36876)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW", Value: uint32(36877)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT", Value: uint32(36877)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES", Value: uint32(36877)},
			{Name: "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB", Value: uint32(36877)},
			{Name: "GL_INT_SAMPLER_CUBE_MAP_ARRAY", Value: uint32(36878)},
			{Name: "GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", Value: uint32(36878)},
			{Name: "GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES", Value: uint32(36878)},
			{Name: "GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB", Value: uint32(36878)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB", Value: uint32(36879)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES", Value: uint32(36879)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY", Value: uint32(36879)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT", Value: uint32(36879)},
			{Name: "GL_ALPHA_SNORM", Value: uint32(36880)},
			{Name: "GL_LUMINANCE_SNORM", Value: uint32(36881)},
			{Name: "GL_LUMINANCE_ALPHA_SNORM", Value: uint32(36882)},
			{Name: "GL_INTENSITY_SNORM", Value: uint32(36883)},
			{Name: "GL_ALPHA8_SNORM", Value: uint32(36884)},
			{Name: "GL_LUMINANCE8_SNORM", Value: uint32(36885)},
			{Name: "GL_LUMINANCE8_ALPHA8_SNORM", Value: uint32(36886)},
			{Name: "GL_INTENSITY8_SNORM", Value: uint32(36887)},
			{Name: "GL_ALPHA16_SNORM", Value: uint32(36888)},
			{Name: "GL_LUMINANCE16_SNORM", Value: uint32(36889)},
			{Name: "GL_LUMINANCE16_ALPHA16_SNORM", Value: uint32(36890)},
			{Name: "GL_INTENSITY16_SNORM", Value: uint32(36891)},
			{Name: "GL_FACTOR_MIN_AMD", Value: uint32(36892)},
			{Name: "GL_FACTOR_MAX_AMD", Value: uint32(36893)},
			{Name: "GL_DEPTH_CLAMP_NEAR_AMD", Value: uint32(36894)},
			{Name: "GL_DEPTH_CLAMP_FAR_AMD", Value: uint32(36895)},
			{Name: "GL_VIDEO_BUFFER_NV", Value: uint32(36896)},
			{Name: "GL_VIDEO_BUFFER_BINDING_NV", Value: uint32(36897)},
			{Name: "GL_FIELD_UPPER_NV", Value: uint32(36898)},
			{Name: "GL_FIELD_LOWER_NV", Value: uint32(36899)},
			{Name: "GL_NUM_VIDEO_CAPTURE_STREAMS_NV", Value: uint32(36900)},
			{Name: "GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV", Value: uint32(36901)},
			{Name: "GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV", Value: uint32(36902)},
			{Name: "GL_LAST_VIDEO_CAPTURE_STATUS_NV", Value: uint32(36903)},
			{Name: "GL_VIDEO_BUFFER_PITCH_NV", Value: uint32(36904)},
			{Name: "GL_VIDEO_COLOR_CONVERSION_MATRIX_NV", Value: uint32(36905)},
			{Name: "GL_VIDEO_COLOR_CONVERSION_MAX_NV", Value: uint32(36906)},
			{Name: "GL_VIDEO_COLOR_CONVERSION_MIN_NV", Value: uint32(36907)},
			{Name: "GL_VIDEO_COLOR_CONVERSION_OFFSET_NV", Value: uint32(36908)},
			{Name: "GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV", Value: uint32(36909)},
			{Name: "GL_PARTIAL_SUCCESS_NV", Value: uint32(36910)},
			{Name: "GL_SUCCESS_NV", Value: uint32(36911)},
			{Name: "GL_FAILURE_NV", Value: uint32(36912)},
			{Name: "GL_YCBYCR8_422_NV", Value: uint32(36913)},
			{Name: "GL_YCBAYCR8A_4224_NV", Value: uint32(36914)},
			{Name: "GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV", Value: uint32(36915)},
			{Name: "GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV", Value: uint32(36916)},
			{Name: "GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV", Value: uint32(36917)},
			{Name: "GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV", Value: uint32(36918)},
			{Name: "GL_Z4Y12Z4CB12Z4CR12_444_NV", Value: uint32(36919)},
			{Name: "GL_VIDEO_CAPTURE_FRAME_WIDTH_NV", Value: uint32(36920)},
			{Name: "GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV", Value: uint32(36921)},
			{Name: "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV", Value: uint32(36922)},
			{Name: "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV", Value: uint32(36923)},
			{Name: "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV", Value: uint32(36924)},
			{Name: "GL_TEXTURE_COVERAGE_SAMPLES_NV", Value: uint32(36933)},
			{Name: "GL_TEXTURE_COLOR_SAMPLES_NV", Value: uint32(36934)},
			{Name: "GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX", Value: uint32(36935)},
			{Name: "GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX", Value: uint32(36936)},
			{Name: "GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX", Value: uint32(36937)},
			{Name: "GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX", Value: uint32(36938)},
			{Name: "GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX", Value: uint32(36939)},
			{Name: "GL_IMAGE_1D", Value: uint32(36940)},
			{Name: "GL_IMAGE_1D_EXT", Value: uint32(36940)},
			{Name: "GL_IMAGE_2D_EXT", Value: uint32(36941)},
			{Name: "GL_IMAGE_2D", Value: uint32(36941)},
			{Name: "GL_IMAGE_3D_EXT", Value: uint32(36942)},
			{Name: "GL_IMAGE_3D", Value: uint32(36942)},
			{Name: "GL_IMAGE_2D_RECT", Value: uint32(36943)},
			{Name: "GL_IMAGE_2D_RECT_EXT", Value: uint32(36943)},
			{Name: "GL_IMAGE_CUBE", Value: uint32(36944)},
			{Name: "GL_IMAGE_CUBE_EXT", Value: uint32(36944)},
			{Name: "GL_IMAGE_BUFFER_OES", Value: uint32(36945)},
			{Name: "GL_IMAGE_BUFFER_EXT", Value: uint32(36945)},
			{Name: "GL_IMAGE_BUFFER", Value: uint32(36945)},
			{Name: "GL_IMAGE_1D_ARRAY_EXT", Value: uint32(36946)},
			{Name: "GL_IMAGE_1D_ARRAY", Value: uint32(36946)},
			{Name: "GL_IMAGE_2D_ARRAY", Value: uint32(36947)},
			{Name: "GL_IMAGE_2D_ARRAY_EXT", Value: uint32(36947)},
			{Name: "GL_IMAGE_CUBE_MAP_ARRAY", Value: uint32(36948)},
			{Name: "GL_IMAGE_CUBE_MAP_ARRAY_OES", Value: uint32(36948)},
			{Name: "GL_IMAGE_CUBE_MAP_ARRAY_EXT", Value: uint32(36948)},
			{Name: "GL_IMAGE_2D_MULTISAMPLE", Value: uint32(36949)},
			{Name: "GL_IMAGE_2D_MULTISAMPLE_EXT", Value: uint32(36949)},
			{Name: "GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT", Value: uint32(36950)},
			{Name: "GL_IMAGE_2D_MULTISAMPLE_ARRAY", Value: uint32(36950)},
			{Name: "GL_INT_IMAGE_1D", Value: uint32(36951)},
			{Name: "GL_INT_IMAGE_1D_EXT", Value: uint32(36951)},
			{Name: "GL_INT_IMAGE_2D", Value: uint32(36952)},
			{Name: "GL_INT_IMAGE_2D_EXT", Value: uint32(36952)},
			{Name: "GL_INT_IMAGE_3D", Value: uint32(36953)},
			{Name: "GL_INT_IMAGE_3D_EXT", Value: uint32(36953)},
			{Name: "GL_INT_IMAGE_2D_RECT", Value: uint32(36954)},
			{Name: "GL_INT_IMAGE_2D_RECT_EXT", Value: uint32(36954)},
			{Name: "GL_INT_IMAGE_CUBE_EXT", Value: uint32(36955)},
			{Name: "GL_INT_IMAGE_CUBE", Value: uint32(36955)},
			{Name: "GL_INT_IMAGE_BUFFER_OES", Value: uint32(36956)},
			{Name: "GL_INT_IMAGE_BUFFER_EXT", Value: uint32(36956)},
			{Name: "GL_INT_IMAGE_BUFFER", Value: uint32(36956)},
			{Name: "GL_INT_IMAGE_1D_ARRAY", Value: uint32(36957)},
			{Name: "GL_INT_IMAGE_1D_ARRAY_EXT", Value: uint32(36957)},
			{Name: "GL_INT_IMAGE_2D_ARRAY", Value: uint32(36958)},
			{Name: "GL_INT_IMAGE_2D_ARRAY_EXT", Value: uint32(36958)},
			{Name: "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT", Value: uint32(36959)},
			{Name: "GL_INT_IMAGE_CUBE_MAP_ARRAY_OES", Value: uint32(36959)},
			{Name: "GL_INT_IMAGE_CUBE_MAP_ARRAY", Value: uint32(36959)},
			{Name: "GL_INT_IMAGE_2D_MULTISAMPLE_EXT", Value: uint32(36960)},
			{Name: "GL_INT_IMAGE_2D_MULTISAMPLE", Value: uint32(36960)},
			{Name: "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY", Value: uint32(36961)},
			{Name: "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT", Value: uint32(36961)},
			{Name: "GL_UNSIGNED_INT_IMAGE_1D_EXT", Value: uint32(36962)},
			{Name: "GL_UNSIGNED_INT_IMAGE_1D", Value: uint32(36962)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_EXT", Value: uint32(36963)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D", Value: uint32(36963)},
			{Name: "GL_UNSIGNED_INT_IMAGE_3D_EXT", Value: uint32(36964)},
			{Name: "GL_UNSIGNED_INT_IMAGE_3D", Value: uint32(36964)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT", Value: uint32(36965)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_RECT", Value: uint32(36965)},
			{Name: "GL_UNSIGNED_INT_IMAGE_CUBE", Value: uint32(36966)},
			{Name: "GL_UNSIGNED_INT_IMAGE_CUBE_EXT", Value: uint32(36966)},
			{Name: "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT", Value: uint32(36967)},
			{Name: "GL_UNSIGNED_INT_IMAGE_BUFFER_OES", Value: uint32(36967)},
			{Name: "GL_UNSIGNED_INT_IMAGE_BUFFER", Value: uint32(36967)},
			{Name: "GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT", Value: uint32(36968)},
			{Name: "GL_UNSIGNED_INT_IMAGE_1D_ARRAY", Value: uint32(36968)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT", Value: uint32(36969)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_ARRAY", Value: uint32(36969)},
			{Name: "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT", Value: uint32(36970)},
			{Name: "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES", Value: uint32(36970)},
			{Name: "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY", Value: uint32(36970)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE", Value: uint32(36971)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT", Value: uint32(36971)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY", Value: uint32(36972)},
			{Name: "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT", Value: uint32(36972)},
			{Name: "GL_MAX_IMAGE_SAMPLES_EXT", Value: uint32(36973)},
			{Name: "GL_MAX_IMAGE_SAMPLES", Value: uint32(36973)},
			{Name: "GL_IMAGE_BINDING_FORMAT_EXT", Value: uint32(36974)},
			{Name: "GL_IMAGE_BINDING_FORMAT", Value: uint32(36974)},
			{Name: "GL_RGB10_A2UI", Value: uint32(36975)},
			{Name: "GL_PATH_FORMAT_SVG_NV", Value: uint32(36976)},
			{Name: "GL_PATH_FORMAT_PS_NV", Value: uint32(36977)},
			{Name: "GL_STANDARD_FONT_NAME_NV", Value: uint32(36978)},
			{Name: "GL_SYSTEM_FONT_NAME_NV", Value: uint32(36979)},
			{Name: "GL_FILE_NAME_NV", Value: uint32(36980)},
			{Name: "GL_PATH_STROKE_WIDTH_NV", Value: uint32(36981)},
			{Name: "GL_PATH_END_CAPS_NV", Value: uint32(36982)},
			{Name: "GL_PATH_INITIAL_END_CAP_NV", Value: uint32(36983)},
			{Name: "GL_PATH_TERMINAL_END_CAP_NV", Value: uint32(36984)},
			{Name: "GL_PATH_JOIN_STYLE_NV", Value: uint32(36985)},
			{Name: "GL_PATH_MITER_LIMIT_NV", Value: uint32(36986)},
			{Name: "GL_PATH_DASH_CAPS_NV", Value: uint32(36987)},
			{Name: "GL_PATH_INITIAL_DASH_CAP_NV", Value: uint32(36988)},
			{Name: "GL_PATH_TERMINAL_DASH_CAP_NV", Value: uint32(36989)},
			{Name: "GL_PATH_DASH_OFFSET_NV", Value: uint32(36990)},
			{Name: "GL_PATH_CLIENT_LENGTH_NV", Value: uint32(36991)},
			{Name: "GL_PATH_FILL_MODE_NV", Value: uint32(36992)},
			{Name: "GL_PATH_FILL_MASK_NV", Value: uint32(36993)},
			{Name: "GL_PATH_FILL_COVER_MODE_NV", Value: uint32(36994)},
			{Name: "GL_PATH_STROKE_COVER_MODE_NV", Value: uint32(36995)},
			{Name: "GL_PATH_STROKE_MASK_NV", Value: uint32(36996)},
			{Name: "GL_COUNT_UP_NV", Value: uint32(37000)},
			{Name: "GL_COUNT_DOWN_NV", Value: uint32(37001)},
			{Name: "GL_PATH_OBJECT_BOUNDING_BOX_NV", Value: uint32(37002)},
			{Name: "GL_CONVEX_HULL_NV", Value: uint32(37003)},
			{Name: "GL_BOUNDING_BOX_NV", Value: uint32(37005)},
			{Name: "GL_TRANSLATE_X_NV", Value: uint32(37006)},
			{Name: "GL_TRANSLATE_Y_NV", Value: uint32(37007)},
			{Name: "GL_TRANSLATE_2D_NV", Value: uint32(37008)},
			{Name: "GL_TRANSLATE_3D_NV", Value: uint32(37009)},
			{Name: "GL_AFFINE_2D_NV", Value: uint32(37010)},
			{Name: "GL_AFFINE_3D_NV", Value: uint32(37012)},
			{Name: "GL_TRANSPOSE_AFFINE_2D_NV", Value: uint32(37014)},
			{Name: "GL_TRANSPOSE_AFFINE_3D_NV", Value: uint32(37016)},
			{Name: "GL_UTF8_NV", Value: uint32(37018)},
			{Name: "GL_UTF16_NV", Value: uint32(37019)},
			{Name: "GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV", Value: uint32(37020)},
			{Name: "GL_PATH_COMMAND_COUNT_NV", Value: uint32(37021)},
			{Name: "GL_PATH_COORD_COUNT_NV", Value: uint32(37022)},
			{Name: "GL_PATH_DASH_ARRAY_COUNT_NV", Value: uint32(37023)},
			{Name: "GL_PATH_COMPUTED_LENGTH_NV", Value: uint32(37024)},
			{Name: "GL_PATH_FILL_BOUNDING_BOX_NV", Value: uint32(37025)},
			{Name: "GL_PATH_STROKE_BOUNDING_BOX_NV", Value: uint32(37026)},
			{Name: "GL_SQUARE_NV", Value: uint32(37027)},
			{Name: "GL_ROUND_NV", Value: uint32(37028)},
			{Name: "GL_TRIANGULAR_NV", Value: uint32(37029)},
			{Name: "GL_BEVEL_NV", Value: uint32(37030)},
			{Name: "GL_MITER_REVERT_NV", Value: uint32(37031)},
			{Name: "GL_MITER_TRUNCATE_NV", Value: uint32(37032)},
			{Name: "GL_SKIP_MISSING_GLYPH_NV", Value: uint32(37033)},
			{Name: "GL_USE_MISSING_GLYPH_NV", Value: uint32(37034)},
			{Name: "GL_PATH_ERROR_POSITION_NV", Value: uint32(37035)},
			{Name: "GL_PATH_FOG_GEN_MODE_NV", Value: uint32(37036)},
			{Name: "GL_ACCUM_ADJACENT_PAIRS_NV", Value: uint32(37037)},
			{Name: "GL_ADJACENT_PAIRS_NV", Value: uint32(37038)},
			{Name: "GL_FIRST_TO_REST_NV", Value: uint32(37039)},
			{Name: "GL_PATH_GEN_MODE_NV", Value: uint32(37040)},
			{Name: "GL_PATH_GEN_COEFF_NV", Value: uint32(37041)},
			{Name: "GL_PATH_GEN_COLOR_FORMAT_NV", Value: uint32(37042)},
			{Name: "GL_PATH_GEN_COMPONENTS_NV", Value: uint32(37043)},
			{Name: "GL_PATH_DASH_OFFSET_RESET_NV", Value: uint32(37044)},
			{Name: "GL_MOVE_TO_RESETS_NV", Value: uint32(37045)},
			{Name: "GL_MOVE_TO_CONTINUES_NV", Value: uint32(37046)},
			{Name: "GL_PATH_STENCIL_FUNC_NV", Value: uint32(37047)},
			{Name: "GL_PATH_STENCIL_REF_NV", Value: uint32(37048)},
			{Name: "GL_PATH_STENCIL_VALUE_MASK_NV", Value: uint32(37049)},
			{Name: "GL_SCALED_RESOLVE_FASTEST_EXT", Value: uint32(37050)},
			{Name: "GL_SCALED_RESOLVE_NICEST_EXT", Value: uint32(37051)},
			{Name: "GL_MIN_MAP_BUFFER_ALIGNMENT", Value: uint32(37052)},
			{Name: "GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV", Value: uint32(37053)},
			{Name: "GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV", Value: uint32(37054)},
			{Name: "GL_PATH_COVER_DEPTH_FUNC_NV", Value: uint32(37055)},
			{Name: "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE", Value: uint32(37063)},
			{Name: "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE", Value: uint32(37064)},
			{Name: "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS", Value: uint32(37065)},
			{Name: "GL_MAX_VERTEX_IMAGE_UNIFORMS", Value: uint32(37066)},
			{Name: "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS", Value: uint32(37067)},
			{Name: "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT", Value: uint32(37067)},
			{Name: "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES", Value: uint32(37067)},
			{Name: "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES", Value: uint32(37068)},
			{Name: "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS", Value: uint32(37068)},
			{Name: "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT", Value: uint32(37068)},
			{Name: "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT", Value: uint32(37069)},
			{Name: "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES", Value: uint32(37069)},
			{Name: "GL_MAX_GEOMETRY_IMAGE_UNIFORMS", Value: uint32(37069)},
			{Name: "GL_MAX_FRAGMENT_IMAGE_UNIFORMS", Value: uint32(37070)},
			{Name: "GL_MAX_COMBINED_IMAGE_UNIFORMS", Value: uint32(37071)},
			{Name: "GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV", Value: uint32(37072)},
			{Name: "GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV", Value: uint32(37073)},
			{Name: "GL_SHADER_STORAGE_BUFFER", Value: uint32(37074)},
			{Name: "GL_SHADER_STORAGE_BUFFER_BINDING", Value: uint32(37075)},
			{Name: "GL_SHADER_STORAGE_BUFFER_START", Value: uint32(37076)},
			{Name: "GL_SHADER_STORAGE_BUFFER_SIZE", Value: uint32(37077)},
			{Name: "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS", Value: uint32(37078)},
			{Name: "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS", Value: uint32(37079)},
			{Name: "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT", Value: uint32(37079)},
			{Name: "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES", Value: uint32(37079)},
			{Name: "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES", Value: uint32(37080)},
			{Name: "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT", Value: uint32(37080)},
			{Name: "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS", Value: uint32(37080)},
			{Name: "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS", Value: uint32(37081)},
			{Name: "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES", Value: uint32(37081)},
			{Name: "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT", Value: uint32(37081)},
			{Name: "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS", Value: uint32(37082)},
			{Name: "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS", Value: uint32(37083)},
			{Name: "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS", Value: uint32(37084)},
			{Name: "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS", Value: uint32(37085)},
			{Name: "GL_MAX_SHADER_STORAGE_BLOCK_SIZE", Value: uint32(37086)},
			{Name: "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT", Value: uint32(37087)},
			{Name: "GL_SYNC_X11_FENCE_EXT", Value: uint32(37089)},
			{Name: "GL_DEPTH_STENCIL_TEXTURE_MODE", Value: uint32(37098)},
			{Name: "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS", Value: uint32(37099)},
			{Name: "GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB", Value: uint32(37099)},
			{Name: "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER", Value: uint32(37100)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER", Value: uint32(37101)},
			{Name: "GL_DISPATCH_INDIRECT_BUFFER", Value: uint32(37102)},
			{Name: "GL_DISPATCH_INDIRECT_BUFFER_BINDING", Value: uint32(37103)},
			{Name: "GL_COLOR_ATTACHMENT_EXT", Value: uint32(37104)},
			{Name: "GL_MULTIVIEW_EXT", Value: uint32(37105)},
			{Name: "GL_MAX_MULTIVIEW_BUFFERS_EXT", Value: uint32(37106)},
			{Name: "GL_CONTEXT_ROBUST_ACCESS_EXT", Value: uint32(37107)},
			{Name: "GL_CONTEXT_ROBUST_ACCESS_KHR", Value: uint32(37107)},
			{Name: "GL_CONTEXT_ROBUST_ACCESS", Value: uint32(37107)},
			{Name: "GL_COMPUTE_PROGRAM_NV", Value: uint32(37115)},
			{Name: "GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV", Value: uint32(37116)},
			{Name: "GL_TEXTURE_2D_MULTISAMPLE", Value: uint32(37120)},
			{Name: "GL_PROXY_TEXTURE_2D_MULTISAMPLE", Value: uint32(37121)},
			{Name: "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES", Value: uint32(37122)},
			{Name: "GL_TEXTURE_2D_MULTISAMPLE_ARRAY", Value: uint32(37122)},
			{Name: "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY", Value: uint32(37123)},
			{Name: "GL_TEXTURE_BINDING_2D_MULTISAMPLE", Value: uint32(37124)},
			{Name: "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES", Value: uint32(37125)},
			{Name: "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY", Value: uint32(37125)},
			{Name: "GL_TEXTURE_SAMPLES", Value: uint32(37126)},
			{Name: "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS", Value: uint32(37127)},
			{Name: "GL_SAMPLER_2D_MULTISAMPLE", Value: uint32(37128)},
			{Name: "GL_INT_SAMPLER_2D_MULTISAMPLE", Value: uint32(37129)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE", Value: uint32(37130)},
			{Name: "GL_SAMPLER_2D_MULTISAMPLE_ARRAY", Value: uint32(37131)},
			{Name: "GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", Value: uint32(37131)},
			{Name: "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", Value: uint32(37132)},
			{Name: "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY", Value: uint32(37132)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY", Value: uint32(37133)},
			{Name: "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES", Value: uint32(37133)},
			{Name: "GL_MAX_COLOR_TEXTURE_SAMPLES", Value: uint32(37134)},
			{Name: "GL_MAX_DEPTH_TEXTURE_SAMPLES", Value: uint32(37135)},
			{Name: "GL_MAX_INTEGER_SAMPLES", Value: uint32(37136)},
			{Name: "GL_MAX_SERVER_WAIT_TIMEOUT", Value: uint32(37137)},
			{Name: "GL_MAX_SERVER_WAIT_TIMEOUT_APPLE", Value: uint32(37137)},
			{Name: "GL_OBJECT_TYPE", Value: uint32(37138)},
			{Name: "GL_OBJECT_TYPE_APPLE", Value: uint32(37138)},
			{Name: "GL_SYNC_CONDITION", Value: uint32(37139)},
			{Name: "GL_SYNC_CONDITION_APPLE", Value: uint32(37139)},
			{Name: "GL_SYNC_STATUS", Value: uint32(37140)},
			{Name: "GL_SYNC_STATUS_APPLE", Value: uint32(37140)},
			{Name: "GL_SYNC_FLAGS_APPLE", Value: uint32(37141)},
			{Name: "GL_SYNC_FLAGS", Value: uint32(37141)},
			{Name: "GL_SYNC_FENCE_APPLE", Value: uint32(37142)},
			{Name: "GL_SYNC_FENCE", Value: uint32(37142)},
			{Name: "GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE", Value: uint32(37143)},
			{Name: "GL_SYNC_GPU_COMMANDS_COMPLETE", Value: uint32(37143)},
			{Name: "GL_UNSIGNALED", Value: uint32(37144)},
			{Name: "GL_UNSIGNALED_APPLE", Value: uint32(37144)},
			{Name: "GL_SIGNALED", Value: uint32(37145)},
			{Name: "GL_SIGNALED_APPLE", Value: uint32(37145)},
			{Name: "GL_ALREADY_SIGNALED_APPLE", Value: uint32(37146)},
			{Name: "GL_ALREADY_SIGNALED", Value: uint32(37146)},
			{Name: "GL_TIMEOUT_EXPIRED", Value: uint32(37147)},
			{Name: "GL_TIMEOUT_EXPIRED_APPLE", Value: uint32(37147)},
			{Name: "GL_CONDITION_SATISFIED", Value: uint32(37148)},
			{Name: "GL_CONDITION_SATISFIED_APPLE", Value: uint32(37148)},
			{Name: "GL_WAIT_FAILED_APPLE", Value: uint32(37149)},
			{Name: "GL_WAIT_FAILED", Value: uint32(37149)},
			{Name: "GL_BUFFER_ACCESS_FLAGS", Value: uint32(37151)},
			{Name: "GL_BUFFER_MAP_LENGTH", Value: uint32(37152)},
			{Name: "GL_BUFFER_MAP_OFFSET", Value: uint32(37153)},
			{Name: "GL_MAX_VERTEX_OUTPUT_COMPONENTS", Value: uint32(37154)},
			{Name: "GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT", Value: uint32(37155)},
			{Name: "GL_MAX_GEOMETRY_INPUT_COMPONENTS", Value: uint32(37155)},
			{Name: "GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES", Value: uint32(37155)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT", Value: uint32(37156)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS", Value: uint32(37156)},
			{Name: "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES", Value: uint32(37156)},
			{Name: "GL_MAX_FRAGMENT_INPUT_COMPONENTS", Value: uint32(37157)},
			{Name: "GL_CONTEXT_PROFILE_MASK", Value: uint32(37158)},
			{Name: "GL_UNPACK_COMPRESSED_BLOCK_WIDTH", Value: uint32(37159)},
			{Name: "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT", Value: uint32(37160)},
			{Name: "GL_UNPACK_COMPRESSED_BLOCK_DEPTH", Value: uint32(37161)},
			{Name: "GL_UNPACK_COMPRESSED_BLOCK_SIZE", Value: uint32(37162)},
			{Name: "GL_PACK_COMPRESSED_BLOCK_WIDTH", Value: uint32(37163)},
			{Name: "GL_PACK_COMPRESSED_BLOCK_HEIGHT", Value: uint32(37164)},
			{Name: "GL_PACK_COMPRESSED_BLOCK_DEPTH", Value: uint32(37165)},
			{Name: "GL_PACK_COMPRESSED_BLOCK_SIZE", Value: uint32(37166)},
			{Name: "GL_TEXTURE_IMMUTABLE_FORMAT", Value: uint32(37167)},
			{Name: "GL_TEXTURE_IMMUTABLE_FORMAT_EXT", Value: uint32(37167)},
			{Name: "GL_SGX_PROGRAM_BINARY_IMG", Value: uint32(37168)},
			{Name: "GL_RENDERBUFFER_SAMPLES_IMG", Value: uint32(37171)},
			{Name: "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG", Value: uint32(37172)},
			{Name: "GL_MAX_SAMPLES_IMG", Value: uint32(37173)},
			{Name: "GL_TEXTURE_SAMPLES_IMG", Value: uint32(37174)},
			{Name: "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG", Value: uint32(37175)},
			{Name: "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG", Value: uint32(37176)},
			{Name: "GL_MAX_DEBUG_MESSAGE_LENGTH_KHR", Value: uint32(37187)},
			{Name: "GL_MAX_DEBUG_MESSAGE_LENGTH", Value: uint32(37187)},
			{Name: "GL_MAX_DEBUG_MESSAGE_LENGTH_AMD", Value: uint32(37187)},
			{Name: "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB", Value: uint32(37187)},
			{Name: "GL_MAX_DEBUG_LOGGED_MESSAGES_KHR", Value: uint32(37188)},
			{Name: "GL_MAX_DEBUG_LOGGED_MESSAGES_AMD", Value: uint32(37188)},
			{Name: "GL_MAX_DEBUG_LOGGED_MESSAGES", Value: uint32(37188)},
			{Name: "GL_MAX_DEBUG_LOGGED_MESSAGES_ARB", Value: uint32(37188)},
			{Name: "GL_DEBUG_LOGGED_MESSAGES", Value: uint32(37189)},
			{Name: "GL_DEBUG_LOGGED_MESSAGES_AMD", Value: uint32(37189)},
			{Name: "GL_DEBUG_LOGGED_MESSAGES_ARB", Value: uint32(37189)},
			{Name: "GL_DEBUG_LOGGED_MESSAGES_KHR", Value: uint32(37189)},
			{Name: "GL_DEBUG_SEVERITY_HIGH_AMD", Value: uint32(37190)},
			{Name: "GL_DEBUG_SEVERITY_HIGH_ARB", Value: uint32(37190)},
			{Name: "GL_DEBUG_SEVERITY_HIGH_KHR", Value: uint32(37190)},
			{Name: "GL_DEBUG_SEVERITY_HIGH", Value: uint32(37190)},
			{Name: "GL_DEBUG_SEVERITY_MEDIUM_ARB", Value: uint32(37191)},
			{Name: "GL_DEBUG_SEVERITY_MEDIUM_AMD", Value: uint32(37191)},
			{Name: "GL_DEBUG_SEVERITY_MEDIUM_KHR", Value: uint32(37191)},
			{Name: "GL_DEBUG_SEVERITY_MEDIUM", Value: uint32(37191)},
			{Name: "GL_DEBUG_SEVERITY_LOW_KHR", Value: uint32(37192)},
			{Name: "GL_DEBUG_SEVERITY_LOW", Value: uint32(37192)},
			{Name: "GL_DEBUG_SEVERITY_LOW_AMD", Value: uint32(37192)},
			{Name: "GL_DEBUG_SEVERITY_LOW_ARB", Value: uint32(37192)},
			{Name: "GL_DEBUG_CATEGORY_API_ERROR_AMD", Value: uint32(37193)},
			{Name: "GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD", Value: uint32(37194)},
			{Name: "GL_DEBUG_CATEGORY_DEPRECATION_AMD", Value: uint32(37195)},
			{Name: "GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD", Value: uint32(37196)},
			{Name: "GL_DEBUG_CATEGORY_PERFORMANCE_AMD", Value: uint32(37197)},
			{Name: "GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD", Value: uint32(37198)},
			{Name: "GL_DEBUG_CATEGORY_APPLICATION_AMD", Value: uint32(37199)},
			{Name: "GL_DEBUG_CATEGORY_OTHER_AMD", Value: uint32(37200)},
			{Name: "GL_DATA_BUFFER_AMD", Value: uint32(37201)},
			{Name: "GL_BUFFER_OBJECT_EXT", Value: uint32(37201)},
			{Name: "GL_PERFORMANCE_MONITOR_AMD", Value: uint32(37202)},
			{Name: "GL_QUERY_OBJECT_AMD", Value: uint32(37203)},
			{Name: "GL_QUERY_OBJECT_EXT", Value: uint32(37203)},
			{Name: "GL_VERTEX_ARRAY_OBJECT_AMD", Value: uint32(37204)},
			{Name: "GL_VERTEX_ARRAY_OBJECT_EXT", Value: uint32(37204)},
			{Name: "GL_SAMPLER_OBJECT_AMD", Value: uint32(37205)},
			{Name: "GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD", Value: uint32(37216)},
			{Name: "GL_QUERY_BUFFER", Value: uint32(37266)},
			{Name: "GL_QUERY_BUFFER_AMD", Value: uint32(37266)},
			{Name: "GL_QUERY_BUFFER_BINDING_AMD", Value: uint32(37267)},
			{Name: "GL_QUERY_BUFFER_BINDING", Value: uint32(37267)},
			{Name: "GL_QUERY_RESULT_NO_WAIT", Value: uint32(37268)},
			{Name: "GL_QUERY_RESULT_NO_WAIT_AMD", Value: uint32(37268)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_X_AMD", Value: uint32(37269)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_X_ARB", Value: uint32(37269)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_X_EXT", Value: uint32(37269)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Y_AMD", Value: uint32(37270)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Y_EXT", Value: uint32(37270)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Y_ARB", Value: uint32(37270)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Z_EXT", Value: uint32(37271)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Z_ARB", Value: uint32(37271)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_Z_AMD", Value: uint32(37271)},
			{Name: "GL_MAX_SPARSE_TEXTURE_SIZE_ARB", Value: uint32(37272)},
			{Name: "GL_MAX_SPARSE_TEXTURE_SIZE_EXT", Value: uint32(37272)},
			{Name: "GL_MAX_SPARSE_TEXTURE_SIZE_AMD", Value: uint32(37272)},
			{Name: "GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD", Value: uint32(37273)},
			{Name: "GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB", Value: uint32(37273)},
			{Name: "GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT", Value: uint32(37273)},
			{Name: "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT", Value: uint32(37274)},
			{Name: "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS", Value: uint32(37274)},
			{Name: "GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB", Value: uint32(37274)},
			{Name: "GL_MIN_SPARSE_LEVEL_AMD", Value: uint32(37275)},
			{Name: "GL_MIN_LOD_WARNING_AMD", Value: uint32(37276)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET", Value: uint32(37277)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET_OES", Value: uint32(37277)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET_EXT", Value: uint32(37277)},
			{Name: "GL_TEXTURE_BUFFER_SIZE", Value: uint32(37278)},
			{Name: "GL_TEXTURE_BUFFER_SIZE_OES", Value: uint32(37278)},
			{Name: "GL_TEXTURE_BUFFER_SIZE_EXT", Value: uint32(37278)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT", Value: uint32(37279)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT", Value: uint32(37279)},
			{Name: "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES", Value: uint32(37279)},
			{Name: "GL_STREAM_RASTERIZATION_AMD", Value: uint32(37280)},
			{Name: "GL_VERTEX_ELEMENT_SWIZZLE_AMD", Value: uint32(37284)},
			{Name: "GL_VERTEX_ID_SWIZZLE_AMD", Value: uint32(37285)},
			{Name: "GL_TEXTURE_SPARSE_EXT", Value: uint32(37286)},
			{Name: "GL_TEXTURE_SPARSE_ARB", Value: uint32(37286)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_INDEX_ARB", Value: uint32(37287)},
			{Name: "GL_VIRTUAL_PAGE_SIZE_INDEX_EXT", Value: uint32(37287)},
			{Name: "GL_NUM_VIRTUAL_PAGE_SIZES_EXT", Value: uint32(37288)},
			{Name: "GL_NUM_VIRTUAL_PAGE_SIZES_ARB", Value: uint32(37288)},
			{Name: "GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT", Value: uint32(37289)},
			{Name: "GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB", Value: uint32(37289)},
			{Name: "GL_NUM_SPARSE_LEVELS_EXT", Value: uint32(37290)},
			{Name: "GL_NUM_SPARSE_LEVELS_ARB", Value: uint32(37290)},
			{Name: "GL_COMPUTE_SHADER", Value: uint32(37305)},
			{Name: "GL_MAX_COMPUTE_UNIFORM_BLOCKS", Value: uint32(37307)},
			{Name: "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS", Value: uint32(37308)},
			{Name: "GL_MAX_COMPUTE_IMAGE_UNIFORMS", Value: uint32(37309)},
			{Name: "GL_MAX_COMPUTE_WORK_GROUP_COUNT", Value: uint32(37310)},
			{Name: "GL_MAX_COMPUTE_WORK_GROUP_SIZE", Value: uint32(37311)},
			{Name: "GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB", Value: uint32(37311)},
			{Name: "GL_UNPACK_FLIP_Y_WEBGL", Value: uint32(37440)},
			{Name: "GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL", Value: uint32(37441)},
			{Name: "GL_CONTEXT_LOST_WEBGL", Value: uint32(37442)},
			{Name: "GL_UNPACK_COLORSPACE_CONVERSION_WEBGL", Value: uint32(37443)},
			{Name: "GL_BROWSER_DEFAULT_WEBGL", Value: uint32(37444)},
			{Name: "GL_SHADER_BINARY_DMP", Value: uint32(37456)},
			{Name: "GL_SMAPHS30_PROGRAM_BINARY_DMP", Value: uint32(37457)},
			{Name: "GL_SMAPHS_PROGRAM_BINARY_DMP", Value: uint32(37458)},
			{Name: "GL_DMP_PROGRAM_BINARY_DMP", Value: uint32(37459)},
			{Name: "GL_GCCSO_SHADER_BINARY_FJ", Value: uint32(37472)},
			{Name: "GL_COMPRESSED_R11_EAC_OES", Value: uint32(37488)},
			{Name: "GL_COMPRESSED_R11_EAC", Value: uint32(37488)},
			{Name: "GL_COMPRESSED_SIGNED_R11_EAC", Value: uint32(37489)},
			{Name: "GL_COMPRESSED_SIGNED_R11_EAC_OES", Value: uint32(37489)},
			{Name: "GL_COMPRESSED_RG11_EAC", Value: uint32(37490)},
			{Name: "GL_COMPRESSED_RG11_EAC_OES", Value: uint32(37490)},
			{Name: "GL_COMPRESSED_SIGNED_RG11_EAC", Value: uint32(37491)},
			{Name: "GL_COMPRESSED_SIGNED_RG11_EAC_OES", Value: uint32(37491)},
			{Name: "GL_COMPRESSED_RGB8_ETC2_OES", Value: uint32(37492)},
			{Name: "GL_COMPRESSED_RGB8_ETC2", Value: uint32(37492)},
			{Name: "GL_COMPRESSED_SRGB8_ETC2", Value: uint32(37493)},
			{Name: "GL_COMPRESSED_SRGB8_ETC2_OES", Value: uint32(37493)},
			{Name: "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES", Value: uint32(37494)},
			{Name: "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", Value: uint32(37494)},
			{Name: "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES", Value: uint32(37495)},
			{Name: "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", Value: uint32(37495)},
			{Name: "GL_COMPRESSED_RGBA8_ETC2_EAC", Value: uint32(37496)},
			{Name: "GL_COMPRESSED_RGBA8_ETC2_EAC_OES", Value: uint32(37496)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", Value: uint32(37497)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES", Value: uint32(37497)},
			{Name: "GL_BLEND_PREMULTIPLIED_SRC_NV", Value: uint32(37504)},
			{Name: "GL_BLEND_OVERLAP_NV", Value: uint32(37505)},
			{Name: "GL_UNCORRELATED_NV", Value: uint32(37506)},
			{Name: "GL_DISJOINT_NV", Value: uint32(37507)},
			{Name: "GL_CONJOINT_NV", Value: uint32(37508)},
			{Name: "GL_BLEND_ADVANCED_COHERENT_NV", Value: uint32(37509)},
			{Name: "GL_BLEND_ADVANCED_COHERENT_KHR", Value: uint32(37509)},
			{Name: "GL_SRC_NV", Value: uint32(37510)},
			{Name: "GL_DST_NV", Value: uint32(37511)},
			{Name: "GL_SRC_OVER_NV", Value: uint32(37512)},
			{Name: "GL_DST_OVER_NV", Value: uint32(37513)},
			{Name: "GL_SRC_IN_NV", Value: uint32(37514)},
			{Name: "GL_DST_IN_NV", Value: uint32(37515)},
			{Name: "GL_SRC_OUT_NV", Value: uint32(37516)},
			{Name: "GL_DST_OUT_NV", Value: uint32(37517)},
			{Name: "GL_SRC_ATOP_NV", Value: uint32(37518)},
			{Name: "GL_DST_ATOP_NV", Value: uint32(37519)},
			{Name: "GL_PLUS_NV", Value: uint32(37521)},
			{Name: "GL_PLUS_DARKER_NV", Value: uint32(37522)},
			{Name: "GL_MULTIPLY_NV", Value: uint32(37524)},
			{Name: "GL_MULTIPLY_KHR", Value: uint32(37524)},
			{Name: "GL_SCREEN_KHR", Value: uint32(37525)},
			{Name: "GL_SCREEN_NV", Value: uint32(37525)},
			{Name: "GL_OVERLAY_KHR", Value: uint32(37526)},
			{Name: "GL_OVERLAY_NV", Value: uint32(37526)},
			{Name: "GL_DARKEN_NV", Value: uint32(37527)},
			{Name: "GL_DARKEN_KHR", Value: uint32(37527)},
			{Name: "GL_LIGHTEN_NV", Value: uint32(37528)},
			{Name: "GL_LIGHTEN_KHR", Value: uint32(37528)},
			{Name: "GL_COLORDODGE_NV", Value: uint32(37529)},
			{Name: "GL_COLORDODGE_KHR", Value: uint32(37529)},
			{Name: "GL_COLORBURN_KHR", Value: uint32(37530)},
			{Name: "GL_COLORBURN_NV", Value: uint32(37530)},
			{Name: "GL_HARDLIGHT_KHR", Value: uint32(37531)},
			{Name: "GL_HARDLIGHT_NV", Value: uint32(37531)},
			{Name: "GL_SOFTLIGHT_NV", Value: uint32(37532)},
			{Name: "GL_SOFTLIGHT_KHR", Value: uint32(37532)},
			{Name: "GL_DIFFERENCE_NV", Value: uint32(37534)},
			{Name: "GL_DIFFERENCE_KHR", Value: uint32(37534)},
			{Name: "GL_MINUS_NV", Value: uint32(37535)},
			{Name: "GL_EXCLUSION_NV", Value: uint32(37536)},
			{Name: "GL_EXCLUSION_KHR", Value: uint32(37536)},
			{Name: "GL_CONTRAST_NV", Value: uint32(37537)},
			{Name: "GL_INVERT_RGB_NV", Value: uint32(37539)},
			{Name: "GL_LINEARDODGE_NV", Value: uint32(37540)},
			{Name: "GL_LINEARBURN_NV", Value: uint32(37541)},
			{Name: "GL_VIVIDLIGHT_NV", Value: uint32(37542)},
			{Name: "GL_LINEARLIGHT_NV", Value: uint32(37543)},
			{Name: "GL_PINLIGHT_NV", Value: uint32(37544)},
			{Name: "GL_HARDMIX_NV", Value: uint32(37545)},
			{Name: "GL_HSL_HUE_KHR", Value: uint32(37549)},
			{Name: "GL_HSL_HUE_NV", Value: uint32(37549)},
			{Name: "GL_HSL_SATURATION_NV", Value: uint32(37550)},
			{Name: "GL_HSL_SATURATION_KHR", Value: uint32(37550)},
			{Name: "GL_HSL_COLOR_KHR", Value: uint32(37551)},
			{Name: "GL_HSL_COLOR_NV", Value: uint32(37551)},
			{Name: "GL_HSL_LUMINOSITY_NV", Value: uint32(37552)},
			{Name: "GL_HSL_LUMINOSITY_KHR", Value: uint32(37552)},
			{Name: "GL_PLUS_CLAMPED_NV", Value: uint32(37553)},
			{Name: "GL_PLUS_CLAMPED_ALPHA_NV", Value: uint32(37554)},
			{Name: "GL_MINUS_CLAMPED_NV", Value: uint32(37555)},
			{Name: "GL_INVERT_OVG_NV", Value: uint32(37556)},
			{Name: "GL_PRIMITIVE_BOUNDING_BOX_EXT", Value: uint32(37566)},
			{Name: "GL_PRIMITIVE_BOUNDING_BOX_OES", Value: uint32(37566)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER", Value: uint32(37568)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_BINDING", Value: uint32(37569)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_START", Value: uint32(37570)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_SIZE", Value: uint32(37571)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE", Value: uint32(37572)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS", Value: uint32(37573)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES", Value: uint32(37574)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER", Value: uint32(37575)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER", Value: uint32(37576)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER", Value: uint32(37577)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER", Value: uint32(37578)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER", Value: uint32(37579)},
			{Name: "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS", Value: uint32(37580)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT", Value: uint32(37581)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES", Value: uint32(37581)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS", Value: uint32(37581)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES", Value: uint32(37582)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS", Value: uint32(37582)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT", Value: uint32(37582)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS", Value: uint32(37583)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT", Value: uint32(37583)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES", Value: uint32(37583)},
			{Name: "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS", Value: uint32(37584)},
			{Name: "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS", Value: uint32(37585)},
			{Name: "GL_MAX_VERTEX_ATOMIC_COUNTERS", Value: uint32(37586)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT", Value: uint32(37587)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES", Value: uint32(37587)},
			{Name: "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS", Value: uint32(37587)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT", Value: uint32(37588)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES", Value: uint32(37588)},
			{Name: "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS", Value: uint32(37588)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES", Value: uint32(37589)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT", Value: uint32(37589)},
			{Name: "GL_MAX_GEOMETRY_ATOMIC_COUNTERS", Value: uint32(37589)},
			{Name: "GL_MAX_FRAGMENT_ATOMIC_COUNTERS", Value: uint32(37590)},
			{Name: "GL_MAX_COMBINED_ATOMIC_COUNTERS", Value: uint32(37591)},
			{Name: "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE", Value: uint32(37592)},
			{Name: "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS", Value: uint32(37593)},
			{Name: "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX", Value: uint32(37594)},
			{Name: "GL_UNSIGNED_INT_ATOMIC_COUNTER", Value: uint32(37595)},
			{Name: "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS", Value: uint32(37596)},
			{Name: "GL_FRAGMENT_COVERAGE_TO_COLOR_NV", Value: uint32(37597)},
			{Name: "GL_FRAGMENT_COVERAGE_COLOR_NV", Value: uint32(37598)},
			{Name: "GL_DEBUG_OUTPUT_KHR", Value: uint32(37600)},
			{Name: "GL_DEBUG_OUTPUT", Value: uint32(37600)},
			{Name: "GL_UNIFORM", Value: uint32(37601)},
			{Name: "GL_UNIFORM_BLOCK", Value: uint32(37602)},
			{Name: "GL_PROGRAM_INPUT", Value: uint32(37603)},
			{Name: "GL_PROGRAM_OUTPUT", Value: uint32(37604)},
			{Name: "GL_BUFFER_VARIABLE", Value: uint32(37605)},
			{Name: "GL_SHADER_STORAGE_BLOCK", Value: uint32(37606)},
			{Name: "GL_IS_PER_PATCH_OES", Value: uint32(37607)},
			{Name: "GL_IS_PER_PATCH", Value: uint32(37607)},
			{Name: "GL_IS_PER_PATCH_EXT", Value: uint32(37607)},
			{Name: "GL_VERTEX_SUBROUTINE", Value: uint32(37608)},
			{Name: "GL_TESS_CONTROL_SUBROUTINE", Value: uint32(37609)},
			{Name: "GL_TESS_EVALUATION_SUBROUTINE", Value: uint32(37610)},
			{Name: "GL_GEOMETRY_SUBROUTINE", Value: uint32(37611)},
			{Name: "GL_FRAGMENT_SUBROUTINE", Value: uint32(37612)},
			{Name: "GL_COMPUTE_SUBROUTINE", Value: uint32(37613)},
			{Name: "GL_VERTEX_SUBROUTINE_UNIFORM", Value: uint32(37614)},
			{Name: "GL_TESS_CONTROL_SUBROUTINE_UNIFORM", Value: uint32(37615)},
			{Name: "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM", Value: uint32(37616)},
			{Name: "GL_GEOMETRY_SUBROUTINE_UNIFORM", Value: uint32(37617)},
			{Name: "GL_FRAGMENT_SUBROUTINE_UNIFORM", Value: uint32(37618)},
			{Name: "GL_COMPUTE_SUBROUTINE_UNIFORM", Value: uint32(37619)},
			{Name: "GL_TRANSFORM_FEEDBACK_VARYING", Value: uint32(37620)},
			{Name: "GL_ACTIVE_RESOURCES", Value: uint32(37621)},
			{Name: "GL_MAX_NAME_LENGTH", Value: uint32(37622)},
			{Name: "GL_MAX_NUM_ACTIVE_VARIABLES", Value: uint32(37623)},
			{Name: "GL_MAX_NUM_COMPATIBLE_SUBROUTINES", Value: uint32(37624)},
			{Name: "GL_NAME_LENGTH", Value: uint32(37625)},
			{Name: "GL_TYPE", Value: uint32(37626)},
			{Name: "GL_ARRAY_SIZE", Value: uint32(37627)},
			{Name: "GL_OFFSET", Value: uint32(37628)},
			{Name: "GL_BLOCK_INDEX", Value: uint32(37629)},
			{Name: "GL_ARRAY_STRIDE", Value: uint32(37630)},
			{Name: "GL_MATRIX_STRIDE", Value: uint32(37631)},
			{Name: "GL_IS_ROW_MAJOR", Value: uint32(37632)},
			{Name: "GL_ATOMIC_COUNTER_BUFFER_INDEX", Value: uint32(37633)},
			{Name: "GL_BUFFER_BINDING", Value: uint32(37634)},
			{Name: "GL_BUFFER_DATA_SIZE", Value: uint32(37635)},
			{Name: "GL_NUM_ACTIVE_VARIABLES", Value: uint32(37636)},
			{Name: "GL_ACTIVE_VARIABLES", Value: uint32(37637)},
			{Name: "GL_REFERENCED_BY_VERTEX_SHADER", Value: uint32(37638)},
			{Name: "GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT", Value: uint32(37639)},
			{Name: "GL_REFERENCED_BY_TESS_CONTROL_SHADER", Value: uint32(37639)},
			{Name: "GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES", Value: uint32(37639)},
			{Name: "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT", Value: uint32(37640)},
			{Name: "GL_REFERENCED_BY_TESS_EVALUATION_SHADER", Value: uint32(37640)},
			{Name: "GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES", Value: uint32(37640)},
			{Name: "GL_REFERENCED_BY_GEOMETRY_SHADER", Value: uint32(37641)},
			{Name: "GL_REFERENCED_BY_GEOMETRY_SHADER_EXT", Value: uint32(37641)},
			{Name: "GL_REFERENCED_BY_GEOMETRY_SHADER_OES", Value: uint32(37641)},
			{Name: "GL_REFERENCED_BY_FRAGMENT_SHADER", Value: uint32(37642)},
			{Name: "GL_REFERENCED_BY_COMPUTE_SHADER", Value: uint32(37643)},
			{Name: "GL_TOP_LEVEL_ARRAY_SIZE", Value: uint32(37644)},
			{Name: "GL_TOP_LEVEL_ARRAY_STRIDE", Value: uint32(37645)},
			{Name: "GL_LOCATION", Value: uint32(37646)},
			{Name: "GL_LOCATION_INDEX", Value: uint32(37647)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_WIDTH", Value: uint32(37648)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_HEIGHT", Value: uint32(37649)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_LAYERS_OES", Value: uint32(37650)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_LAYERS", Value: uint32(37650)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT", Value: uint32(37650)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_SAMPLES", Value: uint32(37651)},
			{Name: "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS", Value: uint32(37652)},
			{Name: "GL_MAX_FRAMEBUFFER_WIDTH", Value: uint32(37653)},
			{Name: "GL_MAX_FRAMEBUFFER_HEIGHT", Value: uint32(37654)},
			{Name: "GL_MAX_FRAMEBUFFER_LAYERS", Value: uint32(37655)},
			{Name: "GL_MAX_FRAMEBUFFER_LAYERS_EXT", Value: uint32(37655)},
			{Name: "GL_MAX_FRAMEBUFFER_LAYERS_OES", Value: uint32(37655)},
			{Name: "GL_MAX_FRAMEBUFFER_SAMPLES", Value: uint32(37656)},
			{Name: "GL_RASTER_MULTISAMPLE_EXT", Value: uint32(37671)},
			{Name: "GL_RASTER_SAMPLES_EXT", Value: uint32(37672)},
			{Name: "GL_MAX_RASTER_SAMPLES_EXT", Value: uint32(37673)},
			{Name: "GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT", Value: uint32(37674)},
			{Name: "GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT", Value: uint32(37675)},
			{Name: "GL_EFFECTIVE_RASTER_SAMPLES_EXT", Value: uint32(37676)},
			{Name: "GL_DEPTH_SAMPLES_NV", Value: uint32(37677)},
			{Name: "GL_STENCIL_SAMPLES_NV", Value: uint32(37678)},
			{Name: "GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV", Value: uint32(37679)},
			{Name: "GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV", Value: uint32(37680)},
			{Name: "GL_COVERAGE_MODULATION_TABLE_NV", Value: uint32(37681)},
			{Name: "GL_COVERAGE_MODULATION_NV", Value: uint32(37682)},
			{Name: "GL_COVERAGE_MODULATION_TABLE_SIZE_NV", Value: uint32(37683)},
			{Name: "GL_WARP_SIZE_NV", Value: uint32(37689)},
			{Name: "GL_WARPS_PER_SM_NV", Value: uint32(37690)},
			{Name: "GL_SM_COUNT_NV", Value: uint32(37691)},
			{Name: "GL_FILL_RECTANGLE_NV", Value: uint32(37692)},
			{Name: "GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV", Value: uint32(37693)},
			{Name: "GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV", Value: uint32(37694)},
			{Name: "GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV", Value: uint32(37695)},
			{Name: "GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV", Value: uint32(37696)},
			{Name: "GL_PROGRAMMABLE_SAMPLE_LOCATION_NV", Value: uint32(37697)},
			{Name: "GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV", Value: uint32(37698)},
			{Name: "GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV", Value: uint32(37699)},
			{Name: "GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB", Value: uint32(37700)},
			{Name: "GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB", Value: uint32(37701)},
			{Name: "GL_CONSERVATIVE_RASTERIZATION_NV", Value: uint32(37702)},
			{Name: "GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV", Value: uint32(37703)},
			{Name: "GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV", Value: uint32(37704)},
			{Name: "GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV", Value: uint32(37705)},
			{Name: "GL_LOCATION_COMPONENT", Value: uint32(37706)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_INDEX", Value: uint32(37707)},
			{Name: "GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE", Value: uint32(37708)},
			{Name: "GL_CLIP_ORIGIN", Value: uint32(37724)},
			{Name: "GL_CLIP_DEPTH_MODE", Value: uint32(37725)},
			{Name: "GL_NEGATIVE_ONE_TO_ONE", Value: uint32(37726)},
			{Name: "GL_ZERO_TO_ONE", Value: uint32(37727)},
			{Name: "GL_CLEAR_TEXTURE", Value: uint32(37733)},
			{Name: "GL_FONT_GLYPHS_AVAILABLE_NV", Value: uint32(37736)},
			{Name: "GL_FONT_TARGET_UNAVAILABLE_NV", Value: uint32(37737)},
			{Name: "GL_FONT_UNAVAILABLE_NV", Value: uint32(37738)},
			{Name: "GL_FONT_UNINTELLIGIBLE_NV", Value: uint32(37739)},
			{Name: "GL_STANDARD_FONT_FORMAT_NV", Value: uint32(37740)},
			{Name: "GL_FRAGMENT_INPUT_NV", Value: uint32(37741)},
			{Name: "GL_UNIFORM_BUFFER_UNIFIED_NV", Value: uint32(37742)},
			{Name: "GL_UNIFORM_BUFFER_ADDRESS_NV", Value: uint32(37743)},
			{Name: "GL_UNIFORM_BUFFER_LENGTH_NV", Value: uint32(37744)},
			{Name: "GL_MULTISAMPLES_NV", Value: uint32(37745)},
			{Name: "GL_SUPERSAMPLE_SCALE_X_NV", Value: uint32(37746)},
			{Name: "GL_SUPERSAMPLE_SCALE_Y_NV", Value: uint32(37747)},
			{Name: "GL_CONFORMANT_NV", Value: uint32(37748)},
			{Name: "GL_NUM_SAMPLE_COUNTS", Value: uint32(37760)},
			{Name: "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE", Value: uint32(37792)},
			{Name: "GL_BGRA8_EXT", Value: uint32(37793)},
			{Name: "GL_TEXTURE_USAGE_ANGLE", Value: uint32(37794)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_ANGLE", Value: uint32(37795)},
			{Name: "GL_PACK_REVERSE_ROW_ORDER_ANGLE", Value: uint32(37796)},
			{Name: "GL_PROGRAM_BINARY_ANGLE", Value: uint32(37798)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_4x4_KHR", Value: uint32(37808)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_5x4_KHR", Value: uint32(37809)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_5x5_KHR", Value: uint32(37810)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_6x5_KHR", Value: uint32(37811)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_6x6_KHR", Value: uint32(37812)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_8x5_KHR", Value: uint32(37813)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_8x6_KHR", Value: uint32(37814)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_8x8_KHR", Value: uint32(37815)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_10x5_KHR", Value: uint32(37816)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_10x6_KHR", Value: uint32(37817)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_10x8_KHR", Value: uint32(37818)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_10x10_KHR", Value: uint32(37819)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_12x10_KHR", Value: uint32(37820)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_12x12_KHR", Value: uint32(37821)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES", Value: uint32(37824)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES", Value: uint32(37825)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES", Value: uint32(37826)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES", Value: uint32(37827)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES", Value: uint32(37828)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES", Value: uint32(37829)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES", Value: uint32(37830)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES", Value: uint32(37831)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES", Value: uint32(37832)},
			{Name: "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES", Value: uint32(37833)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR", Value: uint32(37840)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR", Value: uint32(37841)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR", Value: uint32(37842)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR", Value: uint32(37843)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR", Value: uint32(37844)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR", Value: uint32(37845)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR", Value: uint32(37846)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR", Value: uint32(37847)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR", Value: uint32(37848)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR", Value: uint32(37849)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR", Value: uint32(37850)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR", Value: uint32(37851)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR", Value: uint32(37852)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR", Value: uint32(37853)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES", Value: uint32(37856)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES", Value: uint32(37857)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES", Value: uint32(37858)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES", Value: uint32(37859)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES", Value: uint32(37860)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES", Value: uint32(37861)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES", Value: uint32(37862)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES", Value: uint32(37863)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES", Value: uint32(37864)},
			{Name: "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES", Value: uint32(37865)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG", Value: uint32(37872)},
			{Name: "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG", Value: uint32(37873)},
			{Name: "GL_PERFQUERY_COUNTER_EVENT_INTEL", Value: uint32(38128)},
			{Name: "GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL", Value: uint32(38129)},
			{Name: "GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL", Value: uint32(38130)},
			{Name: "GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL", Value: uint32(38131)},
			{Name: "GL_PERFQUERY_COUNTER_RAW_INTEL", Value: uint32(38132)},
			{Name: "GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL", Value: uint32(38133)},
			{Name: "GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL", Value: uint32(38136)},
			{Name: "GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL", Value: uint32(38137)},
			{Name: "GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL", Value: uint32(38138)},
			{Name: "GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL", Value: uint32(38139)},
			{Name: "GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL", Value: uint32(38140)},
			{Name: "GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL", Value: uint32(38141)},
			{Name: "GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL", Value: uint32(38142)},
			{Name: "GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL", Value: uint32(38143)},
			{Name: "GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL", Value: uint32(38144)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR", Value: uint32(38448)},
			{Name: "GL_MAX_VIEWS_OVR", Value: uint32(38449)},
			{Name: "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR", Value: uint32(38450)},
			{Name: "GL_GS_SHADER_BINARY_MTK", Value: uint32(38464)},
			{Name: "GL_GS_PROGRAM_BINARY_MTK", Value: uint32(38465)},
			{Name: "GL_RASTER_POSITION_UNCLIPPED_IBM", Value: uint32(103010)},
			{Name: "GL_CULL_VERTEX_IBM", Value: uint32(103050)},
			{Name: "GL_ALL_STATIC_DATA_IBM", Value: uint32(103060)},
			{Name: "GL_STATIC_VERTEX_ARRAY_IBM", Value: uint32(103061)},
			{Name: "GL_VERTEX_ARRAY_LIST_IBM", Value: uint32(103070)},
			{Name: "GL_NORMAL_ARRAY_LIST_IBM", Value: uint32(103071)},
			{Name: "GL_COLOR_ARRAY_LIST_IBM", Value: uint32(103072)},
			{Name: "GL_INDEX_ARRAY_LIST_IBM", Value: uint32(103073)},
			{Name: "GL_TEXTURE_COORD_ARRAY_LIST_IBM", Value: uint32(103074)},
			{Name: "GL_EDGE_FLAG_ARRAY_LIST_IBM", Value: uint32(103075)},
			{Name: "GL_FOG_COORDINATE_ARRAY_LIST_IBM", Value: uint32(103076)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_LIST_IBM", Value: uint32(103077)},
			{Name: "GL_VERTEX_ARRAY_LIST_STRIDE_IBM", Value: uint32(103080)},
			{Name: "GL_NORMAL_ARRAY_LIST_STRIDE_IBM", Value: uint32(103081)},
			{Name: "GL_COLOR_ARRAY_LIST_STRIDE_IBM", Value: uint32(103082)},
			{Name: "GL_INDEX_ARRAY_LIST_STRIDE_IBM", Value: uint32(103083)},
			{Name: "GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM", Value: uint32(103084)},
			{Name: "GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM", Value: uint32(103085)},
			{Name: "GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM", Value: uint32(103086)},
			{Name: "GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM", Value: uint32(103087)},
			{Name: "GL_PREFER_DOUBLEBUFFER_HINT_PGI", Value: uint32(107000)},
			{Name: "GL_CONSERVE_MEMORY_HINT_PGI", Value: uint32(107005)},
			{Name: "GL_RECLAIM_MEMORY_HINT_PGI", Value: uint32(107006)},
			{Name: "GL_NATIVE_GRAPHICS_HANDLE_PGI", Value: uint32(107010)},
			{Name: "GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI", Value: uint32(107011)},
			{Name: "GL_NATIVE_GRAPHICS_END_HINT_PGI", Value: uint32(107012)},
			{Name: "GL_ALWAYS_FAST_HINT_PGI", Value: uint32(107020)},
			{Name: "GL_ALWAYS_SOFT_HINT_PGI", Value: uint32(107021)},
			{Name: "GL_ALLOW_DRAW_OBJ_HINT_PGI", Value: uint32(107022)},
			{Name: "GL_ALLOW_DRAW_WIN_HINT_PGI", Value: uint32(107023)},
			{Name: "GL_ALLOW_DRAW_FRG_HINT_PGI", Value: uint32(107024)},
			{Name: "GL_ALLOW_DRAW_MEM_HINT_PGI", Value: uint32(107025)},
			{Name: "GL_STRICT_DEPTHFUNC_HINT_PGI", Value: uint32(107030)},
			{Name: "GL_STRICT_LIGHTING_HINT_PGI", Value: uint32(107031)},
			{Name: "GL_STRICT_SCISSOR_HINT_PGI", Value: uint32(107032)},
			{Name: "GL_FULL_STIPPLE_HINT_PGI", Value: uint32(107033)},
			{Name: "GL_CLIP_NEAR_HINT_PGI", Value: uint32(107040)},
			{Name: "GL_CLIP_FAR_HINT_PGI", Value: uint32(107041)},
			{Name: "GL_WIDE_LINE_HINT_PGI", Value: uint32(107042)},
			{Name: "GL_BACK_NORMALS_HINT_PGI", Value: uint32(107043)},
			{Name: "GL_VERTEX_DATA_HINT_PGI", Value: uint32(107050)},
			{Name: "GL_VERTEX_CONSISTENT_HINT_PGI", Value: uint32(107051)},
			{Name: "GL_MATERIAL_SIDE_HINT_PGI", Value: uint32(107052)},
			{Name: "GL_MAX_VERTEX_HINT_PGI", Value: uint32(107053)},
			{Name: "GL_SKIP_COMPONENTS1_NV", Value: uint32(4294967290)},
			{Name: "GL_SKIP_COMPONENTS2_NV", Value: uint32(4294967291)},
			{Name: "GL_SKIP_COMPONENTS3_NV", Value: uint32(4294967292)},
			{Name: "GL_SKIP_COMPONENTS4_NV", Value: uint32(4294967293)},
			{Name: "GL_NEXT_BUFFER_NV", Value: uint32(4294967294)},
			{Name: "GL_INVALID_INDEX", Value: uint32(4294967295)},
		},
	})
}

func (v GLenum) String() string {
	if s, ok := _GLenum_map[v]; ok {
		return s
	}
	return fmt.Sprintf("GLenum(%d)", v)
}

func (v *GLenum) Parse(s string) error {
	for k, t := range _GLenum_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in GLenum", s)
}

var _TextureKind_map = map[TextureKind]string{}

func init() {
	_TextureKind_map[0] = "UNDEFINED"
	_TextureKind_map[1] = "TEXTURE2D"
	_TextureKind_map[2] = "CUBEMAP"

	ConstantValues = append(ConstantValues, schema.ConstantSet{
		Type: &schema.Primitive{Name: "TextureKind", Method: schema.Uint32},
		Entries: []schema.Constant{
			{Name: "UNDEFINED", Value: uint32(0)},
			{Name: "TEXTURE2D", Value: uint32(1)},
			{Name: "CUBEMAP", Value: uint32(2)},
		},
	})
}

func (v TextureKind) String() string {
	if s, ok := _TextureKind_map[v]; ok {
		return s
	}
	return fmt.Sprintf("TextureKind(%d)", v)
}

func (v *TextureKind) Parse(s string) error {
	for k, t := range _TextureKind_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in TextureKind", s)
}