
<bool> = true
<bool> = false

<bool_> = true
<bool_> = false

<glint> = <TexInt>
<glint> = <fuzzint>
<glint> = <largeint>
<glint> = <sint>
<glint> = <repeatcount>

<glgll> = gl.LINEAR
<glgll> = gl.LINEAR_MIPMAP_NEAREST
<glgll> = <TexInt>

<gl> = gl1
<gl> = gl2

<program> = program1
<program> = program2

<tex> = tex1
<tex> = tex2

<buffer> = buffer1
<buffer> = buffer2

<TexInt> = 0
<TexInt> = 1
<TexInt> = 2
<TexInt> = 4
<TexInt> = 8
<TexInt> = 16
<TexInt> = 32
<TexInt> = 64
<TexInt> = 128

<TexInt_> = 0
<TexInt_> = 1
<TexInt_> = 2
<TexInt_> = 4
<TexInt_> = 8
<TexInt_> = 16
<TexInt_> = 32
<TexInt_> = 64
<TexInt_> = 128

<sint> = 0x7fffff00
<sint> = 0x64
<sint> = 0x3e8
<sint> = 0x4141
<sint> = 0xefff
<sint> = 0xaa
<sint> = 0xaf43
<sint> = -0x5a
<sint> = true
<sint> = false

<largeint> = 536870911
<largeint> = 536870912
<largeint> = 1073741823
<largeint> = 1073741824
<largeint> = 2147483647
<largeint> = 2147483648
<largeint> = 4294967295
<largeint> = 4294967296

<fuzzstring> = <fuzzstringpart>
<fuzzstring> = <fuzzstringpart> + <fuzzstringpart>
<fuzzstring> = <fuzzstringpart> + <fuzzstringpart> + <fuzzstringpart>
<fuzzstringpart> = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
<repeatcount> = 17
<repeatcount> = 65
<repeatcount> = 257
<repeatcount> = 1025
<repeatcount> = 4097
<repeatcount> = 65537
<repeatstr> = String.fromCharCode(<int min=0 max=127>)
<repeatstr> = String.fromCharCode(<int min=0 max=127>).repeat(<repeatcount>)

<GLclampf> = 0.0
<GLclampf> = 0.000005
<GLclampf> = 0.0025
<GLclampf> = 0.1
<GLclampf> = 0.2
<GLclampf> = 0.255
<GLclampf> = 0.275
<GLclampf> = 0.3
<GLclampf> = 0.4
<GLclampf> = 0.5
<GLclampf> = 0.55
<GLclampf> = 0.75
<GLclampf> = 1.0

<GLclampf_> = 0.0
<GLclampf_> = 0.000005
<GLclampf_> = 0.0025
<GLclampf_> = 0.1
<GLclampf_> = 0.2
<GLclampf_> = 0.255
<GLclampf_> = 0.275
<GLclampf_> = 0.3
<GLclampf_> = 0.4
<GLclampf_> = 0.5
<GLclampf_> = 0.55
<GLclampf_> = 0.75
<GLclampf_> = 1.0

<glBin> = 1110011
<glBin> = 1010011
<glBin> = 1000011
<glBin> = 1010001
<glBin> = 1010000

<Glenum> = gl.PACK_ALIGNMENT
<Glenum> = gl.UNPACK_ALIGNMENT
<Glenum> = gl.UNPACK_FLIP_Y_WEBGL
<Glenum> = gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL
<Glenum> = gl.UNPACK_COLORSPACE_CONVERSION_WEBGL
<Glenum> = gl.PACK_ROW_LENGTH
<Glenum> = gl.PACK_SKIP_PIXELS
<Glenum> = gl.PACK_SKIP_ROWS
<Glenum> = gl.UNPACK_ROW_LENGTH
<Glenum> = gl.UNPACK_IMAGE_HEIGHT
<Glenum> = gl.UNPACK_SKIP_PIXELS
<Glenum> = gl.UNPACK_SKIP_ROWS
<Glenum> = gl.UNPACK_SKIP_IMAGES

<glOp> = gl.STATIC_DRAW
<glOp> = gl.DYNAMIC_DRAW
<glOp> = gl.STREAM_DRAW
<glOp> = gl.STATIC_READ
<glOp> = gl.DYNAMIC_READ
<glOp> = gl.STREAM_READ
<glOp> = gl.STATIC_COPY
<glOp> = gl.DYNAMIC_COPY
<glOp> = gl.STREAM_COPY

<Gparam> = gl.ACTIVE_TEXTURE
<Gparam> = gl.ALIASED_LINE_WIDTH_RANGE
<Gparam> = gl.ALIASED_POINT_SIZE_RANGE
<Gparam> = gl.ALPHA_BITS
<Gparam> = gl.ARRAY_BUFFER_BINDING
<Gparam> = gl.BLEND
<Gparam> = gl.BLEND_COLOR
<Gparam> = gl.BLEND_DST_ALPHA
<Gparam> = gl.BLEND_DST_RGB
<Gparam> = gl.BLEND_EQUATION
<Gparam> = gl.BLEND_EQUATION_ALPHA
<Gparam> = gl.BLEND_EQUATION_RGB
<Gparam> = gl.BLEND_SRC_ALPHA
<Gparam> = gl.BLEND_SRC_RGB
<Gparam> = gl.COLOR_CLEAR_VALUE

<GTex> = gl.TEXTURE_2D
<GTex> = gl.TEXTURE_CUBE_MAP
<GTex> = gl.TEXTURE_3D
<GTex> = gl.COLOR_WRITEMASK

<shader> = vShader4
<shader> = vShader3
<shader> = fShader3
<shader> = fShader4

<cShader> = VERTEX_SHADER
<cShader> = FRAGMENT_SHADER

<nm> = 'vColor'
<nm> = 'vDepth'
<nm> = 'oColor'
<nm> = 'oDepth'
<nm> = 'oVertex'
<nm> = 'oTexture'
<nm> = 'uScalingFactor'
<nm> = 'uGlobalColor'
<nm> = 'uRotationVector'

<gbuff> = gl.ARRAY_BUFFER
<gbuff> = gl.ELEMENT_ARRAY_BUFFER
<gbuff> = gl.COPY_READ_BUFFER
<gbuff> = gl.COPY_WRITE_BUFFER
<gbuff> = gl.TRANSFORM_FEEDBACK_BUFFER
<gbuff> = gl.UNIFORM_BUFFER
<gbuff> = gl.PIXEL_PACK_BUFFER
<gbuff> = gl.PIXEL_UNPACK_BUFFER

<fbuff> = gl.FRAMEBUFFER
<fbuff> = gl.DRAW_FRAMEBUFFER
<fbuff> = gl.READ_FRAMEBUFFER

<gTexture> = gl.TEXTURE_2D
<gTexture> = gl.TEXTURE_CUBE_MAP
<gTexture> = gl.TEXTURE_3D
<gTexture> = gl.TEXTURE_2D_ARRAY

<gEq> = gl.FUNC_ADD
<gEq> = gl.FUNC_SUBTRACT
<gEq> = gl.FUNC_REVERSE_SUBTRACT
<gEq> = gl.MIN
<gEq> = gl.MAX

<gEq_> = gl.FUNC_ADD
<gEq_> = gl.FUNC_SUBTRACT
<gEq_> = gl.FUNC_REVERSE_SUBTRACT
<gEq_> = gl.MIN
<gEq_> = gl.MAX

<glFac> = gl.ZERO
<glFac> = gl.ONE
<glFac> = gl.SRC_COLOR
<glFac> = gl.ONE_MINUS_SRC_COLOR
<glFac> = gl.DST_COLOR
<glFac> = gl.ONE_MINUS_DST_COLOR
<glFac> = gl.SRC_ALPHA
<glFac> = gl.ONE_MINUS_SRC_ALPHA
<glFac> = gl.DST_ALPHA
<glFac> = gl.ONE_MINUS_DST_ALPHA
<glFac> = gl.CONSTANT_COLOR
<glFac> = gl.ONE_MINUS_CONSTANT_COLOR
<glFac> = gl.CONSTANT_ALPHA
<glFac> = gl.ONE_MINUS_CONSTANT_ALPHA
<glFac> = gl.SRC_ALPHA_SATURATE

<glFac_> = gl.ZERO
<glFac_> = gl.ONE
<glFac_> = gl.SRC_COLOR
<glFac_> = gl.ONE_MINUS_SRC_COLOR
<glFac_> = gl.DST_COLOR
<glFac_> = gl.ONE_MINUS_DST_COLOR
<glFac_> = gl.SRC_ALPHA
<glFac_> = gl.ONE_MINUS_SRC_ALPHA
<glFac_> = gl.DST_ALPHA
<glFac_> = gl.ONE_MINUS_DST_ALPHA
<glFac_> = gl.CONSTANT_COLOR
<glFac_> = gl.ONE_MINUS_CONSTANT_COLOR
<glFac_> = gl.CONSTANT_ALPHA
<glFac_> = gl.ONE_MINUS_CONSTANT_ALPHA
<glFac_> = gl.SRC_ALPHA_SATURATE

<glMask> = gl.COLOR_BUFFER_BIT
<glMask> = gl.DEPTH_BUFFER_BIT
<glMask> = gl.STENCIL_BUFFER_BIT

<glMask_> = gl.COLOR_BUFFER_BIT
<glMask_> = gl.DEPTH_BUFFER_BIT
<glMask_> = gl.STENCIL_BUFFER_BIT

<glMode> = gl.FRONT
<glMode> = gl.BACK
<glMode> = gl.FRONT_AND_BACK

<glFun> = gl.NEVER
<glFun> = gl.LESS
<glFun> = gl.EQUAL
<glFun> = gl.LEQUAL
<glFun> = gl.GREATER
<glFun> = gl.NOTEQUAL
<glFun> = gl.GEQUAL
<glFun> = gl.ALWAYS

<glCap> = gl.BLEND
<glCap> = gl.CULL_FACE
<glCap> = gl.DEPTH_TEST
<glCap> = gl.DITHER
<glCap> = gl.POLYGON_OFFSET_FILL
<glCap> = gl.SAMPLE_ALPHA_TO_COVERAGE
<glCap> = gl.SAMPLE_COVERAGE
<glCap> = gl.SCISSOR_TEST
<glCap> = gl.STENCIL_TEST

<glMd> = gl.POINTS
<glMd> = gl.LINE_STRIP
<glMd> = gl.LINE_LOOP
<glMd> = gl.LINES
<glMd> = gl.TRIANGLE_STRIP
<glMd> = gl.TRIANGLE_FAN
<glMd> = gl.TRIANGLES

<glType> = gl.UNSIGNED_BYTE
<glType> = gl.UNSIGNED_SHORT

<glType_> = gl.UNSIGNED_BYTE
<glType_> = gl.UNSIGNED_SHORT

<glFront> = gl.CW
<glFront> = gl.CCW

<glMip> = gl.TEXTURE_2D
<glMip> = gl.TEXTURE_CUBE_MAP
<glMip> = gl.TEXTURE_3D
<glMip> = gl.TEXTURE_2D_ARRAY

<glActive> = gl.FLOAT
<glActive> = gl.FLOAT_VEC2
<glActive> = gl.FLOAT_VEC3
<glActive> = gl.FLOAT_VEC4
<glActive> = gl.INT
<glActive> = gl.INT_VEC2
<glActive> = gl.INT_VEC3
<glActive> = gl.INT_VEC4
<glActive> = gl.BOOL
<glActive> = gl.BOOL_VEC2
<glActive> = gl.BOOL_VEC3
<glActive> = gl.BOOL_VEC4
<glActive> = gl.FLOAT_MAT2
<glActive> = gl.FLOAT_MAT3
<glActive> = gl.FLOAT_MAT4
<glActive> = gl.SAMPLER_2D
<glActive> = gl.SAMPLER_CUBE
<glActive> = gl.UNSIGNED_INT
<glActive> = gl.UNSIGNED_INT_VEC2
<glActive> = gl.UNSIGNED_INT_VEC3
<glActive> = gl.UNSIGNED_INT_VEC4
<glActive> = gl.FLOAT_MAT2x3
<glActive> = gl.FLOAT_MAT2x4
<glActive> = gl.FLOAT_MAT3x2
<glActive> = gl.FLOAT_MAT3x4
<glActive> = gl.FLOAT_MAT4x2
<glActive> = gl.FLOAT_MAT4x3
<glActive> = gl.SAMPLER_3D
<glActive> = gl.SAMPLER_2D_SHADOW
<glActive> = gl.SAMPLER_2D_ARRAY
<glActive> = gl.SAMPLER_2D_ARRAY_SHADOW
<glActive> = gl.SAMPLER_CUBE_SHADOW
<glActive> = gl.INT_SAMPLER_2D
<glActive> = gl.INT_SAMPLER_3D
<glActive> = gl.INT_SAMPLER_CUBE
<glActive> = gl.INT_SAMPLER_2D_ARRAY
<glActive> = gl.UNSIGNED_INT_SAMPLER_2D
<glActive> = gl.UNSIGNED_INT_SAMPLER_3D
<glActive> = gl.UNSIGNED_INT_SAMPLER_CUBE
<glActive> = gl.UNSIGNED_INT_SAMPLER_2D_ARRAY

<glTr> = gl.FRAMEBUFFER
<glTr> = gl.DRAW_FRAMEBUFFER
<glTr> = gl.READ_FRAMEBUFFER

<glAttachment> = gl.COLOR_ATTACHMENT0
<glAttachment> = gl.DEPTH_ATTACHMENT
<glAttachment> = gl.STENCIL_ATTACHMENT
<glAttachment> = gl.DEPTH_STENCIL_ATTACHMENT

<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
<glAttachmentObj> = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER

<glpType> = gl.LOW_FLOAT
<glpType> = gl.MEDIUM_FLOAT
<glpType> = gl.HIGH_INT

<gltType> = gl.TEXTURE_MAG_FILTER
<gltType> = gl.TEXTURE_MIN_FILTER
<gltType> = gl.TEXTURE_WRAP_S
<gltType> = gl.TEXTURE_WRAP_T
<gltType> = gl.TEXTURE_BASE_LEVEL
<gltType> = gl.TEXTURE_COMPARE_FUNC
<gltType> = gl.TEXTURE_COMPARE_MODE
<gltType> = gl.TEXTURE_IMMUTABLE_FORMAT
<gltType> = gl.TEXTURE_IMMUTABLE_LEVELS
<gltType> = gl.TEXTURE_MAX_LEVEL
<gltType> = gl.TEXTURE_MAX_LOD
<gltType> = gl.TEXTURE_MIN_LOD
<gltType> = gl.TEXTURE_WRAP_R

<glBind> = gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
<glBind> = gl.VERTEX_ATTRIB_ARRAY_ENABLED
<glBind> = gl.VERTEX_ATTRIB_ARRAY_SIZE
<glBind> = gl.VERTEX_ATTRIB_ARRAY_STRIDE
<glBind> = gl.VERTEX_ATTRIB_ARRAY_TYPE
<glBind> = gl.VERTEX_ATTRIB_ARRAY_NORMALIZED
<glBind> = gl.CURRENT_VERTEX_ATTRIB
<glBind> = gl.VERTEX_ATTRIB_ARRAY_INTEGER
<glBind> = gl.VERTEX_ATTRIB_ARRAY_DIVISOR

<glHint> = gl.GENERATE_MIPMAP_HINT
<glHint> = gl.FRAGMENT_SHADER_DERIVATIVE_HINT

<glMood> = gl.FASTEST
<glMood> = gl.NICEST
<glMood> = gl.DONT_CARE

<glEn> = gl.ALPHA
<glEn> = gl.RGB
<glEn> = gl.RGBA

<glStp> = gl.UNSIGNED_BYTE
<glStp> = gl.UNSIGNED_SHORT_5_6_5
<glStp> = gl.UNSIGNED_SHORT_4_4_4_4
<glStp> = gl.UNSIGNED_SHORT_5_5_5_1
<glStp> = gl.FLOAT

<glStp_> = gl.UNSIGNED_BYTE
<glStp_> = gl.UNSIGNED_SHORT_5_6_5
<glStp_> = gl.UNSIGNED_SHORT_4_4_4_4
<glStp_> = gl.UNSIGNED_SHORT_5_5_5_1
<glStp_> = gl.FLOAT

<glStts> = gl.BYTE
<glStts> = gl.SHORT
<glStts> = gl.UNSIGNED_BYTE
<glStts> = gl.UNSIGNED_SHORT
<glStts> = gl.FLOAT
<glStts> = gl.HALF_FLOAT

<gliFormat> = gl.RGBA4
<gliFormat> = gl.RGB565
<gliFormat> = gl.RGB5_A1
<gliFormat> = gl.DEPTH_COMPONENT16
<gliFormat> = gl.STENCIL_INDEX8
<gliFormat> = gl.DEPTH_STENCIL
<gliFormat> = gl.R8
<gliFormat> = gl.R8UI
<gliFormat> = gl.R8I
<gliFormat> = gl.R16UI
<gliFormat> = gl.R16I
<gliFormat> = gl.R32UI
<gliFormat> = gl.R32I
<gliFormat> = gl.RG8
<gliFormat> = gl.RG8UI
<gliFormat> = gl.RG8I
<gliFormat> = gl.RG16UI
<gliFormat> = gl.RG16I
<gliFormat> = gl.RG32UI
<gliFormat> = gl.RG32I
<gliFormat> = gl.RGB8
<gliFormat> = gl.RGBA8
<gliFormat> = gl.SRGB8_ALPHA8
<gliFormat> = gl.RGB10_A2
<gliFormat> = gl.RGBA8UI
<gliFormat> = gl.DEPTH_COMPONENT24
<gliFormat> = gl.DEPTH_COMPONENT32F
<gliFormat> = gl.DEPTH24_STENCIL8
<gliFormat> = gl.DEPTH32F_STENCIL8

<glMgg> = gl.KEEP
<glMgg> = gl.ZERO
<glMgg> = gl.REPLACE
<glMgg> = gl.INCR
<glMgg> = gl.INCR_WRAP
<glMgg> = gl.DECR
<glMgg> = gl.DECR_WRAP
<glMgg> = gl.INVERT

<glMgg_> = gl.KEEP
<glMgg_> = gl.ZERO
<glMgg_> = gl.REPLACE
<glMgg_> = gl.INCR
<glMgg_> = gl.INCR_WRAP
<glMgg_> = gl.DECR
<glMgg_> = gl.DECR_WRAP
<glMgg_> = gl.INVERT

<_glMgg> = gl.KEEP
<_glMgg> = gl.ZERO
<_glMgg> = gl.REPLACE
<_glMgg> = gl.INCR
<_glMgg> = gl.INCR_WRAP
<_glMgg> = gl.DECR
<_glMgg> = gl.DECR_WRAP
<_glMgg> = gl.INVERT

<glTTrr> = gl.TEXTURE_2D
<glTTrr> = gl.TEXTURE_CUBE_MAP_POSITIVE_X
<glTTrr> = gl.TEXTURE_CUBE_MAP_NEGATIVE_X
<glTTrr> = gl.TEXTURE_CUBE_MAP_POSITIVE_Y
<glTTrr> = gl.TEXTURE_CUBE_MAP_NEGATIVE_Y
<glTTrr> = gl.TEXTURE_CUBE_MAP_POSITIVE_Z
<glTTrr> = gl.TEXTURE_CUBE_MAP_NEGATIVE_Z

<glALPHA> = gl.ALPHA
<glALPHA> = gl.RGB
<glALPHA> = gl.RGBA
<glALPHA> = gl.LUMINANCE
<glALPHA> = gl.LUMINANCE_ALPHA

<glExtStr> = 'ANGLE_instanced_arrays'
<glExtStr> = 'EXT_blend_minmax'
<glExtStr> = 'EXT_color_buffer_float'
<glExtStr> = 'EXT_color_buffer_half_float'
<glExtStr> = 'EXT_disjoint_timer_query'
<glExtStr> = 'EXT_frag_depth'
<glExtStr> = 'EXT_sRGB'
<glExtStr> = 'EXT_shader_texture_lod'
<glExtStr> = 'EXT_texture_filter_anisotropic'
<glExtStr> = 'OES_element_index_uint'
<glExtStr> = 'OES_standard_derivatives'
<glExtStr> = 'OES_texture_float'
<glExtStr> = 'OES_texture_float_linear'
<glExtStr> = 'OES_vertex_array_object'
<glExtStr> = 'WEBGL_color_buffer_float'
<glExtStr> = 'WEBGL_compressed_texture_astc'
<glExtStr> = 'WEBGL_compressed_texture_atc'
<glExtStr> = 'WEBGL_compressed_texture_etc'
<glExtStr> = 'WEBGL_compressed_texture_etc1'
<glExtStr> = 'WEBGL_compressed_texture_pvrtc'
<glExtStr> = 'WEBGL_debug_renderer_info'
<glExtStr> = 'WEBGL_debug_shaders'
<glExtStr> = 'WEBGL_depth_texture'
<glExtStr> = 'WEBGL_draw_buffers'
<glExtStr> = 'WEBGL_lose_context'

<this> = this

<root root=true> = <lines count=50>

!include ../rules/common.txt
!include ../rules/cssproperties.txt

!lineguard try { <line> } catch(e) { }
!varformat fuzzvar%05d
!begin lines

<gl>.activeTexture(gl.TEXTURE<TexInt>);
<gl>.attachShader(<program>, <shader>);
<gl>.getParameter(<Gparam>);
<gl>.linkProgram(<program>);
<gl>.useProgram(<program>);
<gl>.pixelStorei(<Glenum>, <glint>);
<gl>.pixelStorei(<Glenum>, <sint>);
<gl>.bindTexture(<GTex>, tex);
<gl>.bindAttribLocation(<program>, <glint>, <nm>);

var <buffer> = <gl>.createBuffer(); <gl>.bindBuffer(<gbuff>, <buffer>);
if (<buffer> != undefined) {<gl>.deleteBuffer(<buffer>);}
<gl>.isBuffer(<buffer>);
var f<buffer> = <gl>.createBuffer(); <gl>.bindFramebuffer(<fbuff>, f<buffer>);
if (f<buffer> != undefined) {<gl>.deleteFramebuffer(f<buffer>);}
<gl>.isFramebuffer(f<buffer>);
var r<buffer> = <gl>.createBuffer(); <gl>.bindRenderbuffer(gl.RENDERBUFFER, r<buffer>);
if (r<buffer> != undefined) {<gl>.deleteRenderbuffer(r<buffer>);}
<gl>.isRenderbuffer(r<buffer>);
var <tex> = gl.createTexture(); <gl>.bindTexture(<gTexture>, <tex>);
if (<tex> != undefined) {<gl>.deleteTexture(<tex>);}

<gl>.isTexture(<tex>);
<gl>.blendColor(<GLclampf>, <GLclampf_>, <GLclampf>, <GLclampf_>);
<gl>.blendColor(<GLclampf_>, <GLclampf>, <GLclampf_>, <GLclampf>);
<gl>.blendEquation(<gEq>);
<gl>.blendEquationSeparate(<gEq>, <gEq_>);
<gl>.enable(<gl>.BLEND); <gl>.blendFunc(<glFac>, <glFac_>);
<gl>.enable(<gl>.BLEND); <gl>.blendFuncSeparate(<glFac>, <glFac_>, <glFac>, <glFac_>);
var <buffer> = <gl>.createBuffer(); <gl>.bindBuffer(<gbuff>, <buffer>); <gl>.bufferData(<gbuff>, <glint>, <glOp>);
var <buffer> = <gl>.createBuffer(); <gl>.bindBuffer(<gbuff>, <buffer>); <gl>.bufferData(<gbuff>, <glint>, <glOp>); <gl>.bufferSubData(<gbuff>, <glint>, <buffer>, <glint>, <glint>);
<gl>.checkFramebufferStatus(<gl>.FRAMEBUFFER);
<gl>.clear(<glMask>);
<gl>.clear(<glMask> | <glMask_>);
<gl>.clearColor(<GLclampf_>, <GLclampf>, <GLclampf>, <GLclampf_>);
<gl>.clearColor(<GLclampf>, <GLclampf_>, <GLclampf_>, <GLclampf>);
<gl>.clearColor(<GLclampf>, <GLclampf>, <GLclampf_>, <GLclampf>);
<gl>.clearColor(<GLclampf>, <GLclampf>, <GLclampf_>, <GLclampf_>);
<gl>.clearDepth(<GLclampf>);
<gl>.clearStencil(<TexInt>);
<gl>.colorMask(<bool>, <bool_>, <bool>, <bool_>);
<gl>.colorMask(<bool_>, <bool_>, <bool>, <bool>);
<gl>.createShader(<cShader>);
var <tex> = <gl>.createTexture();
<gl>.enable(<gl>.CULL_FACE); <gl>.cullFace(<glMode>);
<gl>.deleteShader(<shader>);
<gl>.enable(gl.DEPTH_TEST); <gl>.depthFunc(<glFun>);
<gl>.depthMask(<bool>);
<gl>.depthRange(<GLclampf>, <GLclampf_>);
<gl>.detachShader(<program>, <shader>);
<gl>.disable(<glCap>);
<gl>.isEnabled(<glCap>);
<gl>.disableVertexAttribArray(<glint>);
<gl>.drawArrays(<glMd>, <TexInt>, <TexInt_>);
<gl>.drawElements(<glMd>, <TexInt>, <glType>, <glType_>);
<gl>.finish();
<gl>.flush();
<gl>.frontFace(<glFront>);
<gl>.generateMipmap(<glMip>);
const info1 = <gl>.getActiveAttrib(<program>, <GLclampf>);
const info2 = <gl>.getActiveAttrib(<program>, <GLclampf>);
const ifo1 = <gl>.getActiveUniform(<program>, <GLclampf>);
const ifo2 = <gl>.getActiveUniform(<program>, <GLclampf>);
<gl>.getAttachedShaders(<program>);
<gl>.getAttribLocation(<program>, <nm>);
<gl>.getBufferParameter(<gbuff>, <glOp>);
<gl>.getContextAttributes();
<gl>.getError();
<gl>.getFramebufferAttachmentParameter(<glTr>, <glAttachment>, <glAttachmentObj>);
<gl>.getProgramInfoLog(<program>);
<gl>.getShaderPrecisionFormat(<cShader>, <glpType>);
var source211 = <gl>.getShaderSource(<shader>);
var source122 = <gl>.getShaderSource(<shader>);
<gl>.getTexParameter(<gTexture>, <gltType>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.getUniform(<program>, loc);
<gl>.getVertexAttrib(<glint>, <glBind>);
<gl>.getVertexAttribOffset(<glint>, gl.VERTEX_ATTRIB_ARRAY_POINTER);
<gl>.hint(<glHint>, <glMood>);
<gl>.lineWidth(<GLclampf>);
var pixels = new Uint8Array(<gl>.drawingBufferWidth * <gl>.drawingBufferHeight * 4); <gl>.readPixels(<glint>, <glint>, <gl>.drawingBufferWidth, <gl>.drawingBufferHeight, <glStp>, <glStp_>, pixels);
<gl>.renderbufferStorage(<gl>.RENDERBUFFER, <gliFormat>, <glint>, <glint>);
<gl>.enable(gl.SAMPLE_COVERAGE); <gl>.sampleCoverage(<GLclampf>, <bool>);
<gl>.scissor(<glint>, <glint>, <GLclampf>, <GLclampf>);
<gl>.enable(gl.STENCIL_TEST); <gl>.stencilFunc(<glFun>, <GLclampf>, <glBin>);
<gl>.enable(gl.STENCIL_TEST); <gl>.stencilFuncSeparate(<glMode>, <glFun>, <GLclampf>, <glBin>);
<gl>.stencilMask(<glBin>);
<gl>.stencilMask(<glMode>, <glBin>);
<gl>.enable(<gl>.STENCIL_TEST); <gl>.stencilOp(<glMgg>, <_glMgg>, <glMgg_>);
<gl>.enable(<gl>.STENCIL_TEST); <gl>.stencilOp(<glMode>, <glMgg>, <_glMgg>, <glMgg_>);
<gl>.texParameterf(<gTexture>, <gltType>, <glgll>);
<gl>.texParameteri(<gTexture>, <gltType>, <glgll>);
<gl>.viewport(<GLclampf>, <GLclampf>, <glint>, <glint>);
<gl>.enableVertexAttribArray(0);
<gl>.enableVertexAttribArray(0); <gl>.vertexAttribPointer(<GLclampf>, <glint>, <glStts>, <bool>, <TexInt>, <glint>);
<gl>.vertexAttrib1f(<glint>, <glint>);
<gl>.vertexAttrib2f(<glint>, <glint>, <glint>);
<gl>.vertexAttrib3f(<glint>, <glint>, <glint>, <glint>);
<gl>.vertexAttrib4f(<glint>, <glint>, <glint>, <glint>, <glint>);
<gl>.vertexAttrib1fv(<glint>, <glint>);
<gl>.vertexAttrib2fv(<glint>, <glint>);
<gl>.vertexAttrib3fv(<glint>, <glint>);
<gl>.vertexAttrib4fv(<glint>, <glint>);
<gl>.validateProgram(<program>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniformMatrix2fv(loc, <bool>, [<glint>,<glint>, <glint>,<glint>]);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniformMatrix3fv(loc, <bool>, [<glint>,<glint>, <glint>,<glint>]);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniformMatrix4fv(loc, <bool>, [<glint>,<glint>, <glint>,<glint>]); 
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform1f(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform1fv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform1i(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform1iv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform2f(loc, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform2fv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform2i(loc, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform2iv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform3f(loc, <glint>, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform3fv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform3i(loc, <glint>, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform3iv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform4f(loc, <glint>, <glint>, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform4fv(loc, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform4i(loc, <glint>, <glint>, <glint>, <glint>);
var loc = <gl>.getUniformLocation(<program>, <nm>); <gl>.uniform4iv(loc, <glint>);
<gl>.texImage2D(<glTTrr>, <GLclampf>, <gliFormat>, <GLclampf>, <GLclampf>, 0, <glStts>, <glStts>, img);
var <buffer> = <gl>.createRenderbuffer(); <gl>.framebufferRenderbuffer(<fbuff>, <glAttachment>, gl.RENDERBUFFER, <buffer>);
var <tex> = <gl>.createTexture(); <gl>.framebufferTexture2D(<fbuff>, <glAttachment>, <glTTrr>, <tex>, <GLclampf>);
var ext = <gl>.getExtension(<glExtStr>);
var vara = <gl>.getFramebufferAttachmentParameter(<glTr>, <glAttachment>, <glAttachmentObj>);
var varb = <gl>.getFramebufferAttachmentParameter(<glTr>, <glAttachment>, <glAttachmentObj>);
if (!<gl>.isContextLost()) {var info = <gl>.getProgramInfoLog(<program>);}

!end lines
